Prefab issue - all appear at same location

Hi

I have a script which instantiates clones of a prefab nicely in a circle around a sphere. The prefabs are static and appear in a line at a set distance, with slight offsets to that it isn't a perfect line. I then have another script on the prefab which sets it off orbiting the sphere.

The problem I have is that when I instantiate 100 clones with the orbit script attached to the original prefab, all of them appear at exactly the same point from the sphere :) All 100 no longer have their own position, even though they do orbit.

How am I losing the nice positioning of the clones by adding the orbit script? It's late...maybe I'm missing something daft...code included below.

Instantiate Code:

 var asteroid : Transform;
 var asteroidCount = 100;
 var radius = 50.0;
 
 function Start () {
 
     for (i = 0; i < asteroidCount; i++){
         
         var angle = i * Mathf.PI * 2 / asteroidCount;
         var randomYPosition = Random.Range(-0.2, 0.2);
         
 //Set position of each ball.
 var pos = Vector3 (Mathf.Cos(angle), randomYPosition, Mathf.Sin(angle)) * radius;
         Instantiate(asteroid, pos, Quaternion.identity);
         
     }
 }

Orbiting code:

 var TimeMultiplier : int = 200000;
 
 var Name : String;
 
 var Parent : Transform;
 
 
 
 enum Orbit {Auto, Manual}
 
 var SetOrbit : Orbit;
 
 
 
 enum Rotation {Auto, Manual}
 
 var SetRotation : Rotation;
 
 
 
 enum Season {Auto, Manual}
 
 var SetSeason : Season;
 
 
 
 var NonPlanarOrbit : boolean;
 
 var TidalLock : boolean;
 
 var LockOrbit : boolean;
 
 var OrbitAngle : float;
 
 var KeepTime : boolean;
 
 private var ThisTransform : Transform;
 
 private var EarthDays : float = 365.242199;
 
 
 
 // Orbit Stats
 
 var OrbitalPeriod : float = 1.0; // Earth Years
 
 var OrbitalDistance : float = 2; // In Au
 
 var OrbitOffset : Vector2 = Vector2(0,0);
 
 var OrbitPosOffset : float;
 
 var OrbitStartPos : float;
 
 var OrbitYears : int;
 
 var OrbitDays : int;
 
 var OrbitHours : int;
 
 var OrbitMinutes : int;
 
 var OrbitSeconds : float;
 
 private var OrbitalTime : float;
 
 private var OrbitalDegSec : float;
 
 
 
 //Rotation Stats
 
 var RotationOffset : float;
 
 var RotationPeriod : float; // Earth Hours
 
 var RotationYears : int;
 
 var RotationDays : int;
 
 var RotationHours : int;
 
 var RotationMinutes : int;
 
 var RotationSeconds : float;
 
 private var RotationDegSec : float;
 
 private var RotationTime : float;
 
 
 
 // Planetary Stats
 
 var AxialTilt : float;
 
 var HoursInDay : int;
 
 var RotInOrbit : int;
 
 //Planet Counters
 
 var CounterYear : int;
 
 var CounterDay : int;
 
 var CounterHour : int;
 
 var CounterMinute : int;
 
 var CounterSecond : float;
 
 var CurrentOrbitPos : float;
 
 var OrbitOffSetYear : boolean;
 
 private var RotCounter : float;
 
 private var OrbCounter : float;
 
 
 
 function Start(){
 
 SetupPlanet();
 
 SetupOrbit();
 
 SetupRotation();
 
 
 
     if(OrbitOffSetYear){
 
         OrbCounter = OrbitPosOffset;
 
     }
 
     if(LockOrbit){
 
         KeepTime = false;
 
     }
 
 }
 
 
 
 function SetupPlanet(){
 
 ThisTransform = transform;
 
 ThisTransform.localEulerAngles.z = AxialTilt;
 
 }
 
 
 
 function SetupOrbit(){
 
     if(SetOrbit == 0){
 
         OrbitalTime = ((((EarthDays * OrbitalPeriod) * 24) * 60) * 60);
 
         OrbitalDegSec = (360 / OrbitalTime) * TimeMultiplier;
 
     }else{
 
         OrbitalPeriod = 0;
 
         OrbitalTime = ((((((((OrbitYears * EarthDays) + OrbitDays) * 24) + OrbitHours) * 60) + OrbitMinutes) * 60) + OrbitSeconds);
 
         OrbitalDegSec = (360 / OrbitalTime) * TimeMultiplier;
 
     }
 
 }
 
 
 
 function SetupRotation(){
 
     if(!TidalLock){
 
         if(SetRotation == 0){
 
             RotationTime = (((24 * RotationPeriod) * 60) * 60);
 
             RotationDegSec = (360 / OrbitalTime) * TimeMultiplier;
 
         }else{
 
             RotationPeriod = 0;
 
             RotationTime = ((((((((RotationYears * EarthDays) + RotationDays) * 24) + RotationHours) * 60) + RotationMinutes) * 60) + RotationSeconds);
 
         }
 
         RotationDegSec = (360 / RotationTime) * TimeMultiplier;
 
         RotInOrbit = Mathf.Round(OrbitalTime / RotationTime);
 
         HoursInDay = ((RotationTime / 60) / 60);
 
     }
 
 }
 
 
 
 function Update(){
 
 // Update Orbit Position
 
     if(!LockOrbit){
 
         var ODS : float = OrbitalDegSec * Time.deltaTime;
 
         OrbitStartPos += ODS;
 
     }
 
 
 
 var rot : Quaternion = Quaternion.Euler(0,OrbitStartPos + OrbitPosOffset, 0);
 
 var DesiredPos : Vector3 = rot * Vector3(0, 0, 1) + Parent.position;
 
 var DesiredDir : Vector3 = (DesiredPos - Parent.position).normalized;
 
 
 
     if(NonPlanarOrbit){
 
         var NPOP = Mathf.Cos(OrbitStartPos*Mathf.Deg2Rad+Mathf.Deg2Rad);
 
     }
 
 
 
 ThisTransform.position = (Parent.position + OrbitOffset) + (DesiredDir * OrbitalDistance) + Vector3(0,NPOP * OrbitAngle,0);
 
 
 
 // Update Rotation
 
     if(TidalLock){
 
         ThisTransform.LookAt(Parent);
 
         if(KeepTime){
 
             UpdateCounters(0, ODS);
 
         }
 
     }else{
 
         var RotDegSec : float = RotationDegSec * Time.deltaTime;
 
         if(KeepTime){
 
             UpdateCounters(RotDegSec, ODS);
 
         }
 
         ThisTransform.Rotate(0,RotDegSec, 0, Space.Self);
 
     }
 
 }
 
 
 
 function UpdateCounters(RotDegSec : float, ODS : float){
 
 
 
 //Count Orbits / Years
 
     if((OrbCounter + ODS) >= 360){
 
         CounterYear += 1;
 
         CounterDay = 0;
 
         OrbCounter = (OrbCounter + ODS) - 360;
 
     }else{
 
         OrbCounter += ODS;
 
     }
 
     
 
 CurrentOrbitPos = OrbCounter;
 
 
 
 //Count Days    
 
     if((RotCounter + RotDegSec)>= 360){
 
         CounterDay += 1;
 
         RotCounter = (RotCounter + RotDegSec) - 360;
 
     }else{
 
         RotCounter += RotDegSec;
 
     }
 
 
 
 var CurrentTime = (RotCounter / 360) * RotationTime;
 
 
 
 //Count Hours
 
 CounterHour = (CurrentTime / 60) / 60;
 
 
 
 //Count Minutes    
 
     if(CounterHour > 0){
 
         CounterMinute = (CurrentTime / 60) - (CounterHour * 60);
 
     }else{
 
         CounterMinute = (CurrentTime / 60);
 
     }
 
 
 
 //Count Seconds
 
     if(CounterHour > 0 && CounterMinute > 0){
 
         CounterSecond = CurrentTime - ((CounterMinute + (CounterHour * 60)) * 60);
 
     }else if(CounterHour > 0 && CounterMinute == 0){
 
         CounterSecond = CurrentTime - ((CounterHour * 60) * 60);
 
     }else if(CounterHour == 0 && CounterMinute > 0){
 
         CounterSecond = CurrentTime - (CounterMinute * 60);
 
     }else if(CounterHour == 0 && CounterMinute == 0){
 
         CounterSecond = CurrentTime;
 
     }
 
 }
 
 
 
 function ClampAngle (angle : float, min : float, max : float) {
 
     if (angle < -360){
 
         angle += 360;
 
     }
 
     if (angle > 360){
 
         angle -= 360;
 
     }
 
     return Mathf.Clamp (angle, min, max);
 
 }

Any pointers would be awesome. Cheers.