Radial/omni directional shooting Problem

You should consider describing what you want and what exactly about your results is not what you expect. It's very hard to provide solutions for "I tried but it isn't working" without knowing how it isn't working.

Your code

You're looking to generate a pattern of projectiles in 2D space around a center point? Well then you would do something much as you were before, but you would ensure that you are instantiating not only with new rotations, but at positions that are rotated about the center point as well.

I'm not sure if this was intentional, but as your code is posted, you are instantiating all projectiles but one on the top-left of the object (assuming positive x is right and positive y is up), one oriented the same as the object to which the script is attached and the others oriented at angles rotated about the z axis.

The following is designed with your posted implementation:

using UnityEngine; using System.Collections;

 public float currentSpeed; //speed to move down at
 public Transform Projectile; //what to shoot
 public float[] angles = new float[] {-40f, -35f, -25f, -10f, 0, 10f, 25f, 35f, 40f};
 private float x; //random x position
 float firingRate = 1.0f; //delay between shots, in seconds
 float lastFired = -100f; //absolute time of last fired shot

 void Start() { //Initialization
     currentSpeed = Random.Range(MinSpeed, MaxSpeed); //Random down speed
     x = Random.Range(0f, 1f); //random x position
     transform.position = new Vector3(x, 7.0f, 0.0f);
 }

 void Update() { //Every Frame
     float amtToMove = currentSpeed * Time.deltaTime; //how far to move this frame
     transform.Translate(-Vector3.up * amtToMove); //move down

     if (Time.time < lastFired + firingRate) return; //we just fired

     //reset position if we've fallen too far
     //You might consider a level manager script elsewhere to destroy enemies
     //that go off the screen and spawn new ones as appropriate
     if (transform.position.y <= -6.0) {
         currentSpeed = Random.Range(MinSpeed, MaxSpeed);
         transform.position = new Vector3(x, 7.0f, 0.0f);
     }

     lastFired = Time.time; //We're firing
     //If we're off the screen, should we really be firing?
     if (transform.position.y < 0f || transform.position.y > 1f) return;
     //We'll only ever fire once with this condition at a speed of 1
     //And we'll fire at the exact same time every pass as the fire rate is also 1

     //Rotating the shot position and orientation is easier if they are aligned
     //get the distance from the center
     //I assume this is to avoid the projectile overlapping the object
     //and uses scale to appropriately scale as the object scales
     Vector3 localShotPos = new Vector3(0, -((new Vector2(transform.localScale.x*8f,
                                    transform.localScale.y*5f)).magnitude));
     //Since your scene appears to only be 1-7 units large,
     //aren't these sizes (8 and 5) a little big?

     foreach(float angle in angles) {
         Quaternion rotation = Quaternion.AngleAxis(angle, transform.forward);
         Vector3 shotPosition = transform.position + rotation * localShotPos;
         Instantiate(Projectile, shotPosition, rotation * transform.rotation);
     }
 }

If you wanted a circular spread, you would only need to set a number of shots and change the foreach loop to something like the following:

float degree = 360f/numberOfShots;
for(float i = -180f; i < 180f; i += degree) {
    Quaternion rotation = Quaternion.AngleAxis(i, transform.forward);
    Vector3 shotPosition = transform.position + rotation * localShotPos;
    Instantiate(Projectile, shotPosition, rotation * transform.rotation);
}

To constrain the circle by some amount and evenly distribute the shots, you would just calculate based on the constraint:

float degree = constraint/ numberOfShots;
for(float i = -constraint/2f; i < constraint/2f; i += degree) {
    Quaternion rotation = Quaternion.AngleAxis(i, transform.forward);
    Vector3 shotPosition = transform.position + rotation * localShotPos;
    Instantiate(Projectile, shotPosition, rotation * transform.rotation);
}

Essentially by controlling your angle increments, you could divine any kind of shot pattern. If you wanted a spiral, at each shot you would just add the extra rotation to your loop controls (or rotate your enemy).

for(float i = -constraint/2f + adjustment; i < constraint/2f; i += degree){
    Quaternion rotation = Quaternion.AngleAxis(i, transform.forward);
    Vector3 shotPosition = transform.position + rotation * localShotPos;
    Instantiate(Projectile, shotPosition, rotation * transform.rotation);
}
adjustment += degree/spiralSteps; //number of rotations before returning to the original

If you wanted your shots centered on some target, there are slightly smarter ways, but the simple approach is to just preform the rotation by the amount to aim at the target first by setting it as the adjustment above:

adjustment = Vector3.Angle(-transform.up, target.position - transform.position);

For the first example, you would add the adjustment to the angle when you calculate the rotation:

Quaternion rotation = Quaternion.AngleAxis(angle+adjustment, transform.forward);

The code you found

As with the code you found and included though, it is actually quicker and easier to instantiate the objects at the center of the transform and then move/rotate from there rather than instantiating at the correct position/rotation. You would do much the same, but with less work:

//You don't need to worry about calculating any positions or anything first
foreach(float angle in angles) {
    Transform instance = (Instantiate(Projectile, transform.position, transform.rotation)
                         as GameObject).transform;
    instance.eulerAngles.z += angle; //rotate
    instance.position += -instance.up * (new Vector2(transform.localScale.x * 8f,
                                         transform.localScale.y * 5f)).magnitude; //offset
}

Also, using that method, translating the script included would give you something like:

//Circle for(int i = 0; i < numberOfShots; i++) { Transform instance = (Instantiate(Projectile, transform.position, transform.rotation) as GameObject).transform; instance.eulerAngles.z += i * 360 / numberOfShots; //rotate //They didn't offset and they are dividing and multiplying for every shot }