public static Distance Generate(IStar primaryStar, IOrbitingBody companionStar, short orbitNumberToGenerate)
        {
            if (companionStar.OrbitNumber >= 99)
            {
                return(OrbitRangeGenerator.Generate(orbitNumberToGenerate));
            }

            IOrbitingBody innerObject = primaryStar.InnerOrbitingBody(companionStar.OrbitNumber);
            IOrbitingBody outerObject = primaryStar.OuterOrbitingBody(companionStar.OrbitNumber);

            Distance min = new Distance(0.1, DistanceUnits.AstronomicalUnit);
            Distance max;

            Distance maxPrimary = companionStar.OrbitalDistance / 4;

            if (innerObject == null &&
                outerObject == null)
            {
                max = maxPrimary;
            }
            else if (innerObject == null)
            {
                Distance maxOuter = (outerObject.OrbitalDistance - companionStar.OrbitalDistance) / 4;

                if (maxOuter > maxPrimary)
                {
                    max = maxPrimary;
                }
                else
                {
                    max = maxOuter;
                }
            }
            else if (outerObject == null)
            {
                max = (companionStar.OrbitalDistance - innerObject.OrbitalDistance) / 4;
            }
            else
            {
                Distance maxInner = (companionStar.OrbitalDistance - innerObject.OrbitalDistance) / 4;
                Distance maxOuter = (outerObject.OrbitalDistance - companionStar.OrbitalDistance) / 4;

                if (maxInner > maxOuter)
                {
                    max = maxOuter;
                }
                else
                {
                    max = maxInner;
                }
            }

            Distance orbitalStep = (max - min) / SystemConstants.MaxOrbits;
            Distance variation   = orbitalStep * .4; //So outer can't hit inner

            Distance baseOrbit = orbitalStep * orbitNumberToGenerate;

            return(PerturbHelper.Change(baseOrbit - variation, baseOrbit + variation));
        }
Example #2
0
        public static double Generate(ISystemBody parent, IOrbitingBody child)
        {
            Distance childOrbitInMeters = child.OrbitalDistance.ToMeters();
            Mass     combinedMass       = (parent.Mass + child.Mass);

            double numerator   = 4 * Math.Pow(Math.PI, 2) * Math.Pow(childOrbitInMeters.Value, 3);
            double denominator = SystemBodyConstants.GravitationalConstant * combinedMass.ToKilograms().Value;

            double t = Math.Sqrt(numerator / denominator);

            return(t);
        }
Example #3
0
 public void AddPlanet(IOrbitingBody planet)
 {
     planet.Parent = this;
     OrbitingBodies.Add(planet);
 }
Example #4
0
 public OrbitingBody(IOrbitingBody parent)
 {
     Parent = parent;
 }
Example #5
0
 public static double Generate(IOrbitingBody planet)
 {
     return(SystemConstants.HabitNum / Math.Sqrt(planet.OrbitalDistance.ToAstronomicalUnits().Value));
 }