static void Main(string[] args)
{
Console.WriteLine("Loading...");
SystemFactory systemFactory = new SystemFactory(true);
StellarSystem stellarSystem = systemFactory.GetStellarSystem();
foreach (APhysicalObject star in stellarSystem.Bodies)
{
Console.WriteLine(star);
}
/*
* TimeSpan timeOffset = new TimeSpan(365, 0, 0, 0, 0);
* //Printer<Orbit>.PrintHeader("orbitRecord.csv", stellarSystem.Orbits[0]);
*
* List<Orbit> orbitalStates = new List<Orbit>();
*
* int max = 3000;
* for (int i = 0; i < max; i++)
* {
* stellarSystem.Orbits[0].UpdateTime(timeOffset);
* orbitalStates.Add((Orbit)stellarSystem.Orbits[0].Clone());
* Console.WriteLine($"{i}/{max}");
* }
* Printer<Orbit>.PrintTable("orbitRecord.csv", orbitalStates);
* Console.WriteLine($"{stellarSystem.Orbits[0].OrbitalPeriod / (24 * 60 * 60 * 365)} years");
*/
Console.WriteLine("Finished...");
Console.ReadLine();
}
private void SetSystem(StellarSystem system)
{
if (system == null)
{
return;
}
_system = system;
_systemMap.SetNewSystem(_system.Planets);
_planetSelector.Items.Clear();
foreach (Planet planet in _system.Planets)
{
_planetSelector.Items.Add(String.Format("Planet {0}", planet.Position));
}
_planetSelector.SelectedIndex = 0;
var text = PlanetText.GetSystemText(_system.Planets);
_systemInfo.SetSystem(_system.Planets);
_orbitMap.SetSystem(_system.Planets);
_planetInfoGroup.TabSpacing = 160;
_planetInfoGroup.SetPlanet(_system.Planets[0]);
_orbitMap.SelectPlanet(0);
_systemMap.SelectPlanet(0);
}
public void SetGalaxy(CasualGodComplex.Galaxy galaxy)
{
SpacePlanets.SharedModels.GameObjects.Galaxy spGalaxy = new SpacePlanets.SharedModels.GameObjects.Galaxy();
spGalaxy.Stars = new List <SpacePlanets.SharedModels.GameObjects.Star>();
foreach (var star in galaxy.Stars)
{
SpacePlanets.SharedModels.GameObjects.Star newStar = new SpacePlanets.SharedModels.GameObjects.Star();
StellarSystem system = StarformCore.Generator.GenerateStellarSystem(star.Name);
newStar.Id = star.Id;
newStar.Name = star.Name;
newStar.AgeYears = system.Star.AgeYears;
newStar.BinaryMass = system.Star.BinaryMass;
newStar.Eccentricity = system.Star.Eccentricity;
newStar.EcosphereRadiusAU = system.Star.EcosphereRadiusAU;
newStar.Luminosity = system.Star.Luminosity;
/* According to https://earthsky.org/astronomy-essentials/stellar-luminosity-the-true-brightness-of-stars
*
* The luminosity of any star is the product of the radius squared times the surface temperature raised to the fourth power.
* Given a star whose radius is 3 solar and a surface temperature that’s 2 solar, we can figure that star’s luminosity with the equation below:
* whereby L = luminosity, R = radius and T = surface temperature:
* L = R2 x T4
*/
newStar.Mass = system.Star.Mass;
newStar.SemiMajorAxisAU = system.Star.SemiMajorAxisAU;
newStar.X = (int)Math.Round(star.Position.X * 10);
newStar.Y = (int)Math.Round(star.Position.Y * 10);
newStar.Z = (int)Math.Round(star.Position.Z * 10);
spGalaxy.Stars.Add(newStar);
}
Galaxy = spGalaxy;
}
public ABody(string name, StellarSystem stellarSystem)
{
_name = name;
_stellarSystem = stellarSystem;
_uuid = Guid.NewGuid();
_childOrbit = new List <Orbit>();
}
public static StellarSystem Generate(int x, int y)
{
var output = new StellarSystem();
output.X = x;
output.Y = y;
output.SystemNature = SystemNatureGenerator.Generate();
//Add Primary
output.Stars.Add(StarGenerator.Generate(1));
//Add Secondary Star
if (output.SystemNature == SystemNature.Binary ||
output.SystemNature == SystemNature.Trinary)
{
output.Stars.Add(StarGenerator.Generate(2));
}
//Add Third Star
if (output.SystemNature == SystemNature.Trinary)
{
output.Stars.Add(StarGenerator.Generate(3));
}
return(output);
}
public StellarSystem Generate(StellarSystem parent, int position)
{
var system = new SingleObjectSystem(parent);
system.CenterObject = GenerateCenter(system, position);
system.Satellites = GenerateSatellites(system, position);
return(system);
}
private StellarSystem GenerateSingleStarSystem(StellarSystem parent, int position)
{
var system = new SingleObjectSystem(parent);
var star = _starGenerator.Generate(system, position);
system.CenterObject = star;
return(system);
}
public StellarSystem Generate(StellarSystem parent, int position)
{
var system = new SingleObjectSystem(parent);
// Generate the center planets
system.CenterObject = GenerateCenter(system, position);
// TODO: Generate sub systems (Satellites)
return(system);
}
private StellarSystem GenerateMultiSatelliteSystem(StellarSystem parent, int position, uint countObjects)
{
var system = new MultiObjectSystem(parent);
for (var i = 0; i < countObjects; i++)
{
var starSystem = GenerateSingleSatelliteSystem(system, position);
system.CenterSystems.Add(starSystem);
}
return(system);
}
public static List <ISystemBody> Generate(StellarSystem stellarSystem, int starToGenerate)
{
var star = stellarSystem.Stars[starToGenerate - 1];
var orbits = OrbitsGenerator.Generate(stellarSystem, starToGenerate);
List <ISystemBody> output = new List <ISystemBody>();
for (int i = 0; i < SystemConstants.MaxOrbits; i++)
{
Orbit o = orbits[i];
switch (o.OrbitType)
{
case OrbitTypes.Unavailable:
//Remove objects that can't exist due to orbit not being available
o.OccupiedType = null;
break;
case OrbitTypes.Inner:
if (o.OccupiedType == null)
{
o.OccupiedType = OccupiedTypes.World;
}
break;
case OrbitTypes.Habitable:
if (o.OccupiedType == null)
{
o.OccupiedType = OccupiedTypes.World;
}
break;
case OrbitTypes.Outer:
if (o.OccupiedType == null)
{
o.OccupiedType = OccupiedTypes.World;
}
break;
}
if (o.OccupiedType != null)
{
var systemBody = SystemBodyGenerator.Generate((short)i, o.OrbitalDistance, o.OccupiedType, o.OrbitType,
star, stellarSystem);
star.OrbitingBodies.Add(systemBody.OrbitNumber, systemBody);
}
}
return(output);
}
public SolarSystem Generate(StellarSystem parent)
{
var name = _solarSystemNameGenerator.Generate();
var solarSystem = new SolarSystem(parent)
{
Name = name
};
solarSystem.CenterSystems = GenerateCenter(solarSystem, 0);
solarSystem.Satellites = GenerateSatellites(solarSystem, 1);
return(solarSystem);
}
private StellarSystem GenerateMultiStarSystem(StellarSystem parent, int position)
{
var countStars = RandomCalculator.SelectByWeight(_multiStarCountOccurrences);
var system = new MultiObjectSystem(parent);
for (var i = 0; i < countStars; i++)
{
var starSystem = GenerateSingleStarSystem(system, position);
system.CenterSystems.Add(starSystem);
}
return(system);
}
private List <StellarSystem> GenerateCenter(StellarSystem parent, int position)
{
var center = new List <StellarSystem>();
var starsToCreate = RandomCalculator.SelectByWeight(_starOccurrences);
for (var i = 0; i < starsToCreate; i++)
{
var isMultiSystem = RandomCalculator.SelectByWeight(_multiStarOccurrences);
var system = GenerateCenter(parent, position, isMultiSystem);
center.Add(system);
}
return(center);
}
public Moon Generate(StellarSystem parent, int position)
{
var prefab = GeneratePrefab();
var scale = GenerateScale();
var distance = GenerateDistance();
var moon = new Moon(parent)
{
Id = Guid.NewGuid(),
PrefabName = prefab,
Scale = scale,
DistanceToCenter = distance,
};
return(moon);
}
void Start()
{
systemOrigin = GameObject.Find("SystemOrigin");
SystemCreator systemCreator = systemOrigin.GetComponent<SystemCreator>();
System = new StellarSystem(systemCreator, systemOrigin);
for (int i = 0; i < StellarSystem.PlanetQuantity; i++)
{
if (System.Planets[i].OrbitalPeriod < 0.01f)
{
System.Planets[i].OrbitalPeriod = 0.01f;
}
SetPosition(i, System.PlanetProgresses[i]);
}
}
private List <StellarSystem> GenerateSatellites(StellarSystem parent, int position)
{
var satelliteSystems = new List <StellarSystem>();
var countSatellites = RandomCalculator.SelectByWeight(_satelliteOccurrences);
for (var i = position; i <= countSatellites; i++)
{
var multiSatelliteCount = RandomCalculator.SelectByWeight(_multiSatelliteCountOccurrences);
var satelliteSystem = GenerateSatelliteSystem(parent, position, multiSatelliteCount);
satelliteSystems.Add(satelliteSystem);
}
return(satelliteSystems);
}
public static StellarSystem Generate(int x, int y)
{
var output = new StellarSystem();
output.X = x;
output.Y = y;
output.SystemNature = SystemNatureGenerator.Generate();
//Add Primary
IStar primary = StarGenerator.Generate(1);
output.Stars.Add(primary);
output.CombinedLuminosity = primary.Luminosity;
//Add Secondary Star
if (output.SystemNature == SystemNature.Binary ||
output.SystemNature == SystemNature.Trinary)
{
IStar star = StarGenerator.Generate(2, output.Stars[0]);
output.Stars.Add(star);
}
//Add Third Star
if (output.SystemNature == SystemNature.Trinary)
{
output.Stars.Add(StarGenerator.Generate(3, output.Stars[0]));
}
//Generate primary star bodies
SystemBodiesGenerator.Generate(output, 0);
if (output.Stars.Count > 1)
{
SystemBodiesGenerator.Generate(output, 1);
}
if (output.Stars.Count > 2)
{
SystemBodiesGenerator.Generate(output, starToGenerate: 2);
}
return(output);
}
public static IOrbitingBody Generate(short orbitNumber, Distance orbitalDistance, string occupiedType,
string orbitType, IStar parentStar, StellarSystem stellarSystem)
{
switch (occupiedType)
{
case OccupiedTypes.GasGiant:
return(GasGiantGenerator.Generate(orbitalDistance, orbitNumber, occupiedType, orbitType, parentStar, stellarSystem.CombinedLuminosity));
case OccupiedTypes.CapturedPlanet:
case OccupiedTypes.World:
return(WorldGenerator.Generate(orbitalDistance, orbitNumber, occupiedType, orbitType, parentStar, stellarSystem.CombinedLuminosity));
case OccupiedTypes.Planetoid:
break;
case OccupiedTypes.Star:
//Do nothing for this. Should already be done
break;
}
return(null);
}
public Star(StellarSystem parent) : base(parent)
{
}
private StellarSystem GenerateSatelliteSystem(StellarSystem parent, int position, uint countObjects)
{
return(countObjects == 1
? GenerateSingleSatelliteSystem(parent, position)
: GenerateMultiSatelliteSystem(parent, position, countObjects));
}
private StellarSystem GenerateSingleSatelliteSystem(StellarSystem parent, int position)
{
// TODO: Implement different satellites
return(_planetSystemGenerator.Generate(parent, position));
}
public APhysicalObject(string name, StellarSystem stellarSystem)
: base(name, stellarSystem)
{
}
public SolarSystem(StellarSystem parent) : base(parent)
{
}
public Moon(StellarSystem parent) : base(parent)
{
}
private StellarSystem GenerateCenter(StellarSystem parent, int position, bool isMultiSystem)
{
return(isMultiSystem == false
? GenerateSingleStarSystem(parent, position)
: GenerateMultiStarSystem(parent, position));
}
private Moon GenerateCenter(StellarSystem parent, int position)
{
return(_moonGenerator.Generate(parent, position));
}
public Planet(StellarSystem parent) : base(parent)
{
}
public static List <Orbit> Generate(StellarSystem stellarSystem, int starToGenerate = 1)
{
Star primaryStar = (Star)stellarSystem.Stars[0];
CompanionStar secondaryStar = null;
if (stellarSystem.Stars.Count > 1)
{
secondaryStar = (CompanionStar)stellarSystem.Stars[1];
}
CompanionStar tertiaryStar = null;
if (stellarSystem.Stars.Count > 2)
{
tertiaryStar = (CompanionStar)stellarSystem.Stars[2];
}
IStar currentStar = stellarSystem.Stars[starToGenerate - 1];
List <Orbit> output = new List <Orbit>();
int habitableZone = -2;
for (short i = 0; i < SystemConstants.MaxOrbits; i++)
{
Distance orbitalDistance;
if (currentStar == primaryStar ||
currentStar == tertiaryStar) //All tertiary stars are put at far orbit
{
orbitalDistance = OrbitRangeGenerator.Generate(i);
}
else
{
orbitalDistance = CompanionStarOrbitalDistanceGenerator.Generate(primaryStar, secondaryStar, i);
}
Orbit o = new Orbit
{
OrbitalDistance = orbitalDistance,
OccupiedType = null,
OrbitType = OrbitTypeGenerator.Generate(orbitalDistance, primaryStar.Luminosity, 0)
};
if (o.OrbitType == OrbitTypes.Habitable)
{
habitableZone = i;
}
if (o.OrbitType == OrbitTypes.Outer &&
habitableZone == -2)
{
habitableZone = i - 1;
}
output.Add(o);
}
if (habitableZone == -2)
{
habitableZone = 10;
}
currentStar.HabitableZone = (short)habitableZone;
int numberOfOrbits = NumberOfOrbitsGenerator.Generate(currentStar.Classification, currentStar.LuminosityClass);
int emptyOrbits = NumberOfEmptyOrbitsGenerator.Generate(currentStar.Classification);
RandomOrbitAssignment.Assign(output, emptyOrbits, OccupiedTypes.Empty, -2);
int capturedPlanets = NumberOfCapturedPlanetsGenerator.Generate(currentStar.Classification);
RandomOrbitAssignment.Assign(output, capturedPlanets, OccupiedTypes.CapturedPlanet);
int gasGiants = NumberOfGasGiantsGenerator.Generate(currentStar.Classification);
RandomOrbitAssignment.Assign(output, gasGiants, OccupiedTypes.GasGiant, -3 + habitableZone);
int planetoids = NumberOfPlanetoidsGenerator.Generate();
//Note Slight deviation from source.
RandomOrbitAssignment.Assign(output, planetoids, OccupiedTypes.Planetoid, -1);
//Clear out orbits in excess of Number of Orbits, but keep captured planets
for (int i = 0; i < SystemConstants.MaxOrbits; i++)
{
Orbit o = output[i];
if (i > numberOfOrbits)
{
if (o.OccupiedType != OccupiedTypes.CapturedPlanet)
{
o.OccupiedType = null;
}
}
else
{
if (o.OccupiedType == OccupiedTypes.Empty)
{
o.OccupiedType = null;
}
}
}
if (secondaryStar != null &&
currentStar == primaryStar)
{
secondaryStar.OrbitNumber = CompanionStarOrbitGenerator.Generate();
if (secondaryStar.OrbitNumber < 99)
{
if (secondaryStar.OrbitNumber > 2)
{
for (int i = secondaryStar.OrbitNumber / 2; i < secondaryStar.OrbitNumber; i++)
{
Orbit o = output[i];
o.OrbitType = OrbitTypes.Star;
o.OccupiedType = null;
}
}
else
{
Orbit o = output[secondaryStar.OrbitNumber];
o.OccupiedType = OccupiedTypes.Star;
o.OrbitType = OrbitTypes.Star;
o = output[secondaryStar.OrbitNumber + 1];
o.OccupiedType = null;
o.OrbitType = OrbitTypes.Star;
}
secondaryStar.OrbitalDistance = output[secondaryStar.OrbitNumber].OrbitalDistance;
stellarSystem.CombinedLuminosity += SystemConstants.HabitNum /
Math.Sqrt(secondaryStar.OrbitalDistance.ToAstronomicalUnits().Value);
}
else
{
//No impact on luminosity
secondaryStar.OrbitalDistance = FarOrbitDistanceGenerator.Generate();
}
secondaryStar.OrbitalPeriod = OrbitalPeriodGenerator.Generate(primaryStar, secondaryStar);
secondaryStar.OrbitEccentricity = OrbitalEccentricityGenerator.Generate();
secondaryStar.AxialTilt = AxialTiltGenerator.Generate();
secondaryStar.AxialTiltEffect = TiltEffectGenerator.Generate(secondaryStar.AxialTilt);
}
//Third stars a pushed to a far orbit
//No impact on luminosity
if (tertiaryStar != null &&
currentStar == primaryStar)
{
if (secondaryStar.OrbitNumber == 99)
{
tertiaryStar.OrbitNumber = 100;
}
else
{
tertiaryStar.OrbitNumber = 99;
}
tertiaryStar.OrbitalDistance = FarOrbitDistanceGenerator.Generate();
tertiaryStar.OrbitalPeriod = OrbitalPeriodGenerator.Generate(primaryStar, tertiaryStar);
tertiaryStar.OrbitEccentricity = OrbitalEccentricityGenerator.Generate();
tertiaryStar.AxialTilt = AxialTiltGenerator.Generate();
tertiaryStar.AxialTiltEffect = TiltEffectGenerator.Generate(tertiaryStar.AxialTilt);
}
return(output);
}
protected StellarObject(StellarSystem parent) : base(parent)
{
}
public void BuilderTestFixedWidth()
{
var star = new StellarSystem()
{
IsBinarySystem = false,
Name = "Sol",
StarType = "Yellow Dwarf",
Radius = 695.700
};
var planets = new List <Planet>()
{
new Planet()
{
Name = "Mercury", DistanceFromSun = 57.91, OrderFromSun = 1
},
new Planet()
{
Name = "Venus", DistanceFromSun = 108.2, OrderFromSun = 2
},
new Planet()
{
Name = "Earth", DistanceFromSun = 149.6, OrderFromSun = 3
},
new Planet()
{
Name = "Mars", DistanceFromSun = 227.9, OrderFromSun = 4
},
new Planet()
{
Name = "Jupiter", DistanceFromSun = 778.5, OrderFromSun = 5
},
new Planet()
{
Name = "Saturn", DistanceFromSun = 1429, OrderFromSun = 6
},
new Planet()
{
Name = "Uranus", DistanceFromSun = 2877, OrderFromSun = 7
},
new Planet()
{
Name = "Neptune", DistanceFromSun = 4498, OrderFromSun = 8
},
};
var serializer = new FixedWidthSerializer();
File.Delete("estplanetsfixedwithmulti.txt");
var transport = new LocalFileTransport {
FilePath = $"testplanetsfixedwithmulti.txt"
};
var build = new OutputBuilder()
.SetSerializer(serializer)
.AddData(star)
.AddListData(planets)
// .SetSerializer(new DataIntegrationJsonSerializer())
.AddData(new Galaxy()
{
Name = "Alpha Centauri"
});
var integ = new Integrator();
integ.SendData(build, transport);
// var result = a.SendAsyncData(build, transport);
return;
}
