public SunData GetLatest()
{
lock (latestCacheLock)
{
if (latestCache == null)
{
try
{
latestCache = context.SunData.OrderByDescending(sd => sd.Date).FirstOrDefault();
}
catch (Exception ex)
{
logger.LogError(ex, $"Failed to fetch sun information from database.");
}
}
if (latestCache == null)
{
return new SunData {
ID = 0, Date = DateTime.Today.AddDays(-1), Sunrise = DateTime.Today.AddDays(-1).AddHours(8), Sunset = DateTime.Today.AddDays(-1).AddHours(20)
}
}
;
return(latestCache);
}
}
}
/// <summary>
/// load Sun datas
/// </summary>
public void LoadSun()
{
SunData data = SaveSystem.LoadSun();
slider.maxValue = data.maxValue;
sliderSeted = data.sliderCondition;
}
//wrapper class for the main light in the scene
public SunData GetData()
{
var data = new SunData();
data.rotation = transform.rotation;
data.position = transform.position;
data.scale = transform.localScale;
return(data);
}
public void GenerateSun()
{
Sun = new SunData
{
SizeFactor = sunRadius(),
Radius = (ulong)(baseSizeSun * Sun.SizeFactor),
Mass = sunMass(Sun.SizeFactor),
Temperature = sunTemp(Sun.SizeFactor),
name = "Sun-" + SolarSystemID.ToString()
};
}
//Michael Schmidt
/// <summary>
/// Saves impotertend datas from Sun Script
/// </summary>
/// <param name="sun"></param>
public static void SaveSun(Sun sun)
{
BinaryFormatter formatter = new BinaryFormatter();
string path = Application.persistentDataPath + "/sun.fun";
FileStream stream = new FileStream(path, FileMode.Create);
SunData data = new SunData(sun);
formatter.Serialize(stream, data);
stream.Close();
}
private async Task MockDatabase(DefaultContext context)
{
bool containsSunData = await context.SunData.AnyAsync();
if (!containsSunData)
{
SunData sunData = new SunData();
sunData.Date = DateTime.Today.AddDays(-1);
sunData.Sunrise = sunData.Date.Add(new TimeSpan(7, 38, 0));
sunData.Sunset = sunData.Date.Add(new TimeSpan(17, 57, 0));
await context.AddAsync(sunData);
}
await context.SaveChangesAsync();
}
public void Test_CalculateSolarPosition_TooHighDeltaT_ShouldThrowException()
{
var data = new SunData(
observationTime: new DateTime(2003, 10, 17, 12, 30, 30),
timezone: -7,
deltaUT1: 0,
deltaT: 67000,
latitude: 39.742476,
longitude: -105.1786,
elevation: 1830.14,
temperature: 11,
pressure: 820,
refraction: null);
SunPositionCalculator.CalculateSunPosition(data);
}
public void Test_PartOfDayChecker_ForFullDay_ShouldReturnCorrectResults()
{
for (DateTime observationTime = new DateTime(2016, 6, 28); observationTime <= new DateTime(2016, 6, 29); observationTime = observationTime.AddMinutes(10))
{
var data = new SunData(
observationTime: observationTime,
timezone: 3,
deltaUT1: 0,
deltaT: 67,
latitude: 42.72275253,
longitude: 23.2992956,
elevation: 540,
temperature: 10,
pressure: 940,
refraction: null);
SunPositionCalculator.CalculateSunPosition(data);
var zenithAngle = data.TopocentricZenithAngle;
var azimuth = data.AstronomicalTopocentricAzimuth;
var twilightZenithAngle = 90 + PartOfDayChecker.TwilightElevation;
var partOfDay = PartOfDayChecker.GetPartOfDay(observationTime, new TimeSpan(3, 0, 0), 42.72275253, 23.2992956);
// Sanity checks
Assert.IsTrue(zenithAngle >= 0 && zenithAngle <= 180);
Assert.IsTrue(azimuth >= 0 && azimuth <= 360);
if (partOfDay == PartOfDay.Night)
{
Assert.IsTrue(zenithAngle >= twilightZenithAngle);
}
else if (partOfDay == PartOfDay.Dawn)
{
Assert.IsTrue(zenithAngle > 90 && zenithAngle < twilightZenithAngle);
Assert.IsTrue(azimuth > 180);
}
else if (partOfDay == PartOfDay.Day)
{
Assert.IsTrue(zenithAngle < 90);
}
else if (partOfDay == PartOfDay.Dusk)
{
Assert.IsTrue(zenithAngle > 90 && zenithAngle < twilightZenithAngle);
Assert.IsTrue(azimuth <= 180);
}
}
}
public void Test_CalculateSolarPosition_ShouldCalculateIntermediateValuesCorrectly()
{
var data = new SunData(
observationTime: new DateTime(2003, 10, 17, 12, 30, 30),
timezone: -7,
deltaUT1: 0,
deltaT: 67,
latitude: 39.742476,
longitude: -105.1786,
elevation: 1830.14,
temperature: 11,
pressure: 820,
refraction: null);
SunPositionCalculator.CalculateSunPosition(data);
Assert.AreEqual(data.JulianDay, 2452930.312847, 5e-7);
Assert.AreEqual(data.EarthHeliocentricLongitude, 24.0182616917, DefaultAccuracy);
Assert.AreEqual(data.EarthHeliocentricLatitude, -0.0001011219, DefaultAccuracy);
Assert.AreEqual(data.EarthRadiusVector, 0.9965422974, DefaultAccuracy);
Assert.AreEqual(data.GeocentricLongitude, 204.0182616917, DefaultAccuracy);
Assert.AreEqual(data.GeocentricLatitude, 0.0001011219, DefaultAccuracy);
Assert.AreEqual(data.LongitudeNutation, -0.00399840, 5e-9);
Assert.AreEqual(data.ObliquityNutation, 0.00166657, 5e-9);
Assert.AreEqual(data.TrueEclipticObliquity, 23.440465, 5e-7);
Assert.AreEqual(data.ApparentSunLongitude, 204.0085519281, DefaultAccuracy);
Assert.AreEqual(data.SunRightAscension, 202.22741, 5e-6);
Assert.AreEqual(data.SunDeclination, -9.31434, 5e-6);
Assert.AreEqual(data.ObserverHourAngle, 11.105900, 5e-5);
Assert.AreEqual(data.TopocentricLocalHourAngle, 11.10629, 5e-5);
Assert.AreEqual(data.TopocentricSunRightAscension, 202.22704, 5e-6);
Assert.AreEqual(data.TopocentricSunDeclination, -9.316179, 5e-7);
Assert.AreEqual(data.TopocentricZenithAngle, 50.11162, 5e-6);
Assert.AreEqual(data.TopocentricAzimuth, 194.34024, 5e-6);
}
public SolarSystem(SolarSystemData Data)
{
Suns = new Sun[Data.Suns.Length];
OrbitingPlanets = new Planet[Data.Planets.Length];
systemObj = new GameObject();
systemObj.name = Data.Name;
systemObj.transform.position = Vector3.zero;
systemObj.transform.SetParent(GameObject.FindGameObjectWithTag("Canvas").transform, true);
// Create Suns, Planets and their Moons
for (int i = 0; i < Suns.Length; i++)
{
SunData sd = Data.Suns[i];
Sun sun = new Sun(sd.Name, sd.Type, sd.Color, sd.Radius, sd.Mass, sd.Age, systemObj);
sun.SetPosition(sd.Position);
Suns[i] = sun;
}
for (int i = 0; i < OrbitingPlanets.Length; i++)
{
PlanetData pd = Data.Planets[i];
Orbit orbit = Orbit.Create(pd.Apoapsis, pd.Periapsis, Suns[pd.OrbitingIndex]);
systemLogScaleBase = systemLogScaleBase > Mathf.Log(orbit.SemiMajor) ? Mathf.Log(orbit.SemiMajor) : systemLogScaleBase;
Debug.Log(pd.Name + " Orbit info, T: " + orbit.Period + " Apoapsis: " + orbit.ApoApsis + " Periapsis: " + orbit.PeriApsis);
Planet planet = new Planet(pd.Name, pd.Type, pd.Color, pd.Radius, pd.Mass, orbit, Suns[pd.OrbitingIndex].GameObject);
if (pd.Moons != null)
{
int nr = pd.Moons.Length;
planet.Moons = new Moon[nr];
for (int j = 0; j < nr; j++)
{
MoonData md = pd.Moons[j];
Orbit moonOrbit = Orbit.Create(md.Apoapsis, md.Periapsis, planet);
planet.Moons[j] = new Moon(md.Name, md.Type, md.Color, md.Radius, md.Mass, moonOrbit, md.Approachable, planet.GameObject);
}
}
OrbitingPlanets[i] = planet;
}
Scaling.LogBase = Mathf.Floor(systemLogScaleBase);
TimeAcceleration = Scaling.SpeedUpFactor;
SetOrbitingPositions(0);
}
public void Test_CalculateSolarPosition_NEQuadrantDawn()
{
// Moscow
var data = new SunData(
observationTime: new DateTime(2016, 6, 10, 3, 0, 0),
timezone: 4,
deltaUT1: 0,
deltaT: 67,
latitude: 55.7558,
longitude: 37.6173,
elevation: 151,
temperature: 5.8,
pressure: 1013.25,
refraction: null);
SunPositionCalculator.CalculateSunPosition(data);
Assert.AreEqual(data.TopocentricZenithAngle, 98.879283, 5e-6);
Assert.AreEqual(data.TopocentricAzimuth, 21.124674, 5e-5);
}
public void Test_CalculateSolarPosition_SouthernCircumpolarRegion()
{
// Antarctica
var data = new SunData(
observationTime: new DateTime(2016, 6, 10, 12, 30, 0),
timezone: 8,
deltaUT1: 0,
deltaT: 67,
latitude: -76.566667,
longitude: 110.2,
elevation: 2500,
temperature: -45,
pressure: 1013.25,
refraction: null);
SunPositionCalculator.CalculateSunPosition(data);
Assert.AreEqual(data.TopocentricZenithAngle, 99.615244, 5e-6);
Assert.AreEqual(data.TopocentricAzimuth, 2.023090, 5e-5);
}
public void Test_CalculateSolarPosition_SWQuadrant()
{
// Sao Paulo
var data = new SunData(
observationTime: new DateTime(2016, 6, 10, 12, 30, 0),
timezone: -3,
deltaUT1: 0,
deltaT: 67,
latitude: -23.5505,
longitude: -46.6333,
elevation: 760,
temperature: 22.5,
pressure: 1013.25,
refraction: null);
SunPositionCalculator.CalculateSunPosition(data);
Assert.AreEqual(data.TopocentricZenithAngle, 46.965500, 5e-6);
Assert.AreEqual(data.TopocentricAzimuth, 352.472097, 5e-5);
}
public void Test_CalculateSolarPosition_SEQuadrant()
{
// Perth
var data = new SunData(
observationTime: new DateTime(2016, 6, 10, 12, 30, 0),
timezone: 8,
deltaUT1: 0,
deltaT: 67,
latitude: -31.9505,
longitude: 115.8605,
elevation: 31.5,
temperature: 17.8,
pressure: 1013.25,
refraction: null);
SunPositionCalculator.CalculateSunPosition(data);
Assert.AreEqual(data.TopocentricZenithAngle, 55.067639, 5e-6);
Assert.AreEqual(data.TopocentricAzimuth, 356.079664, 5e-5);
}
public void Test_CalculateSolarPosition_NWQuadrant()
{
// Chicago
var data = new SunData(
observationTime: new DateTime(2016, 6, 10, 12, 30, 0),
timezone: -5,
deltaUT1: 0,
deltaT: 67,
latitude: 41.8781,
longitude: -87.6298,
elevation: 181,
temperature: 9.8,
pressure: 1013.25,
refraction: null);
SunPositionCalculator.CalculateSunPosition(data);
Assert.AreEqual(data.TopocentricZenithAngle, 19.259226, 5e-6);
Assert.AreEqual(data.TopocentricAzimuth, 165.863616, 5e-5);
}
//Michael Schmidt
/// <summary>
/// Load sun Datas
/// </summary>
/// <returns></returns>
public static SunData LoadSun()
{
string path = Application.persistentDataPath + "/sun.fun";
if (true)
{
BinaryFormatter formatter = new BinaryFormatter();
FileStream stream = new FileStream(path, FileMode.Open);
SunData data = formatter.Deserialize(stream) as SunData;
stream.Close();
return(data);
}
else
{
Debug.LogError("Save file not found in " + path);
return(null);
}
}
public void Test_CalculateSolarPosition_NorthernCircumpolarRegion()
{
// Longyearbyen
var data = new SunData(
observationTime: new DateTime(2016, 6, 10, 12, 30, 0),
timezone: 1,
deltaUT1: 0,
deltaT: 67,
latitude: 78.2232,
longitude: 15.6267,
elevation: 100,
temperature: -5.8,
pressure: 1013.25,
refraction: null);
SunPositionCalculator.CalculateSunPosition(data);
Assert.AreEqual(data.TopocentricZenithAngle, 55.276166, 5e-6);
Assert.AreEqual(data.TopocentricAzimuth, 189.234844, 5e-5);
}
public bool Add(DateTime date, DateTime sunrise, DateTime sunset)
{
lock (latestCacheLock)
{
if (context.SunData.Any(sd => sd.Date == date))
{
return(false);
}
logger.LogInformation("Updating sun information.");
try
{
SunData sunData = new()
{
Date = date,
Sunrise = sunrise,
Sunset = sunset
};
context.Add(sunData);
bool result = context.SaveChanges() > 0;
if (latestCache == null || (result && sunData.Date > latestCache.Date))
{
latestCache = sunData;
}
return(result);
}
catch (Exception ex)
{
logger.LogError(ex, $"Failed to store sun information in database ({date.ToShortDateString()}).");
return(false);
}
}
}
void SomeInitializationMethod()
{
Data = new SunData();
Analysis = new SunAnalysis(); // etc
}
public static ZonePack GenerateZone(
ItemManager itemManager,
ZoneGenerationSettings zoneSettings,
Galaxy galaxy,
GalaxyZone galaxyZone,
bool isTutorial = false)
{
var pack = new ZonePack();
var random = new Random(unchecked ((uint)galaxyZone.Name.GetHashCode()) ^ hash(galaxyZone.Position));
var density = saturate(galaxy.Background.CloudDensity(galaxyZone.Position) / 2);
pack.Radius = zoneSettings.ZoneRadius.Evaluate(density);
pack.Mass = zoneSettings.ZoneMass.Evaluate(density);
var targetSubzoneCount = zoneSettings.SubZoneCount.Evaluate(density);
//Debug.Log($"Generating zone at position {zone.Position} with radius {zoneRadius} and mass {zoneMass}");
var planets = new List <GeneratorPlanet>();
if (targetSubzoneCount > 1)
{
var zoneBoundary = new Circle(float2.zero, pack.Radius * zoneSettings.ZoneBoundaryRadius);
float boundaryTangentRadius(float2 point) => - zoneBoundary.DistanceTo(point);
var occupiedAreas = new List <Circle>();
float tangentRadius(float2 point) => min(boundaryTangentRadius(point), occupiedAreas.Min(circle => circle.DistanceTo(point)));
var startPosition = random.NextFloat(pack.Radius * .25f, pack.Radius * .5f) * random.NextFloat2Direction();
occupiedAreas.Add(new Circle(startPosition, boundaryTangentRadius(startPosition)));
int samples = 0;
while (occupiedAreas.Count < targetSubzoneCount && samples < MaximumPlacementSamples)
{
samples = 0;
for (int i = 0; i < MaximumPlacementSamples; i++)
{
var samplePos = random.NextFloat2(-pack.Radius, pack.Radius);
var rad = tangentRadius(samplePos);
if (rad > 0)
{
occupiedAreas.Add(new Circle(samplePos, rad));
break;
}
samples++;
}
}
var totalArea = occupiedAreas.Sum(c => c.Area);
foreach (var c in occupiedAreas)
{
planets.AddRange(GenerateEntities(zoneSettings, ref random, c.Area / totalArea * pack.Mass, c.Radius, c.Center));
}
}
else
{
planets.AddRange(GenerateEntities(zoneSettings, ref random, pack.Mass, pack.Radius, float2.zero));
}
// Create collections to map between zone generator output and database entries
var orbitMap = new Dictionary <GeneratorPlanet, OrbitData>();
var orbitInverseMap = new Dictionary <OrbitData, GeneratorPlanet>();
// Create orbit database entries
pack.Orbits = planets.Select(planet =>
{
var data = new OrbitData
{
FixedPosition = planet.FixedPosition,
Distance = new ReactiveProperty <float>(planet.Distance),
//Period = planet.Period,
Phase = planet.Phase
};
orbitMap[planet] = data;
orbitInverseMap[data] = planet;
return(data);
}).ToList();
// Link OrbitData parents to database GUIDs
foreach (var data in pack.Orbits)
{
data.Parent = orbitInverseMap[data].Parent != null
? orbitMap[orbitInverseMap[data].Parent].ID
: Guid.Empty;
}
// Cache resource densities
// var resourceMaps = mapLayers.Values
// .ToDictionary(m => m.ID, m => m.Evaluate(zone.Position, settings.ShapeSettings));
pack.Planets = planets.Where(p => !p.Empty).Select(planet =>
{
// Dictionary<Guid, float> planetResources = new Dictionary<Guid, float>();
BodyType bodyType = planet.Belt ? BodyType.Asteroid :
planet.Mass > zoneSettings.SunMass ? BodyType.Sun :
planet.Mass > zoneSettings.GasGiantMass ? BodyType.GasGiant :
planet.Mass > zoneSettings.PlanetMass ? BodyType.Planet : BodyType.Planetoid;
// foreach (var r in resources)
// {
// if ((bodyType & r.ResourceBodyType) != 0)
// {
// float quantity = ResourceValue(ref random, settings, r, r.ResourceDensity.Aggregate(1f, (m, rdm) => m * resourceMaps[rdm]));
// if (r.Floor < quantity) planetResources.Add(r.ID, quantity);
// }
// }
BodyData planetData;
switch (bodyType)
{
case BodyType.Asteroid:
planetData = new AsteroidBeltData();
break;
case BodyType.Planetoid:
case BodyType.Planet:
planetData = new PlanetData();
break;
case BodyType.GasGiant:
planetData = new GasGiantData();
break;
case BodyType.Sun:
planetData = new SunData();
break;
default:
throw new ArgumentOutOfRangeException();
}
planetData.Mass.Value = planet.Mass;
planetData.Orbit = orbitMap[planet].ID;
// planetData.Resources = planetResources;
planetData.Name.Value = planetData.ID.ToString().Substring(0, 8);
if (planetData is AsteroidBeltData beltData)
{
beltData.Asteroids =
Enumerable.Range(0, (int)(zoneSettings.AsteroidCount.Evaluate(beltData.Mass.Value * orbitMap[planet].Distance.Value)))
.Select(_ => new Asteroid
{
Distance = orbitMap[planet].Distance.Value + random.NextFloat() * (random.NextFloat() - .5f) * zoneSettings.AsteroidBeltWidth.Evaluate(orbitMap[planet].Distance.Value),
Phase = random.NextFloat(),
Size = random.NextFloat(),
RotationSpeed = zoneSettings.AsteroidRotationSpeed.Evaluate(random.NextFloat())
})
//.OrderByDescending(a=>a.Size)
.ToArray();
}
else if (planetData is GasGiantData gas)
{
if (gas is SunData sun)
{
float primary = random.NextFloat();
float secondary = frac(primary + 1 + zoneSettings.SunSecondaryColorDistance * (random.NextFloat() > .5 ? 1 : -1));
gas.Colors.Value = new []
{
float4(ColorMath.HsvToRgb(float3(primary, zoneSettings.SunColorSaturation, .5f)), 0),
float4(ColorMath.HsvToRgb(float3(secondary, zoneSettings.SunColorSaturation, 1)), 1)
};
sun.FogTintColor.Value = ColorMath.HsvToRgb(float3(primary, zoneSettings.SunFogTintSaturation, 1));
sun.LightColor.Value = ColorMath.HsvToRgb(float3(primary, zoneSettings.SunLightSaturation, 1));
gas.FirstOffsetDomainRotationSpeed.Value = 5;
}
else
{
// Define primary color and two adjacent colors
float primary = random.NextFloat();
float right = frac(primary + zoneSettings.GasGiantBandColorSeparation);
float left = frac(primary + 1 - zoneSettings.GasGiantBandColorSeparation);
// Create n time keys from 0 to 1
var bandCount = (int)(zoneSettings.GasGiantBandCount.Evaluate(random.NextFloat()) + .5f);
var times = Enumerable.Range(0, bandCount)
.Select(i => (float)i / (bandCount - 1));
// Each band has a chance of being either the primary or one of the adjacent hues
// Saturation and Value are random with curves applied
gas.Colors.Value = times
.Select(time => float4(ColorMath.HsvToRgb(float3(
random.NextFloat() > zoneSettings.GasGiantBandAltColorChance ? primary : (random.NextFloat() > .5f ? right : left),
zoneSettings.GasGiantBandSaturation.Evaluate(random.NextFloat()),
zoneSettings.GasGiantBandSaturation.Evaluate(random.NextFloat()))), time))
.ToArray();
gas.FirstOffsetDomainRotationSpeed.Value = 0;
}
gas.AlbedoRotationSpeed.Value = -3;
gas.FirstOffsetRotationSpeed.Value = 5;
gas.SecondOffsetRotationSpeed.Value = 10;
gas.SecondOffsetDomainRotationSpeed.Value = -25;
}
return(planetData);
}).ToList();
var nearestFaction = galaxy.Factions.MinBy(f => galaxy.HomeZones[f].Distance[galaxyZone]);
var nearestFactionHomeZone = galaxy.HomeZones[nearestFaction];
var factionPresence = nearestFaction.InfluenceDistance - nearestFactionHomeZone.Distance[galaxyZone] + 1;
var storyStations = galaxyZone.Locations.Where(story => story.Type == LocationType.Station).ToArray();
var stationCount = (int)(random.NextFloat() * (factionPresence + 1)) + storyStations.Length;
var potentialLagrangePoints = planets
.Where(p => p.Parent != null && p.Parent.Children
.TrueForAll(c => !(c != p && abs(c.Distance - p.Distance) < .1f))) // Filter Rosettes
.OrderBy(p => p.Distance)
.ToArray();
// Pick a selection from the middle of the distribution
var selectedStationOrbits = potentialLagrangePoints
.Skip(potentialLagrangePoints.Length / 2)
.Take(stationCount)
.Select(p => orbitMap[p])
.ToArray();
var loadoutGenerators = new Dictionary <Faction, LoadoutGenerator>();
LoadoutGenerator GetLoadoutGenerator(Faction faction)
{
if (!loadoutGenerators.ContainsKey(faction))
{
loadoutGenerators[faction] = isTutorial
? new LoadoutGenerator(ref random, itemManager, faction, .5f)
: new LoadoutGenerator(ref random, itemManager, galaxy, galaxyZone, faction, .5f);
}
return(loadoutGenerators[faction]);
}
OrbitData CreateLagrangeOrbit(OrbitData baseOrbit)
{
var lagrangeOrbit = new OrbitData
{
ID = Guid.NewGuid(),
Parent = baseOrbit.Parent,
Distance = new ReactiveProperty <float>(baseOrbit.Distance.Value),
Phase = baseOrbit.Phase + PI / 3 * sign(random.NextFloat() - .5f)
};
pack.Orbits.Add(lagrangeOrbit);
return(lagrangeOrbit);
}
void PlaceTurret(OrbitData orbit, LoadoutGenerator loadoutGenerator, int distanceMultiplier)
{
var phase = 20f * distanceMultiplier / orbit.Distance.Value;
var turretOrbit = new OrbitData
{
ID = Guid.NewGuid(),
Parent = orbit.Parent,
Distance = new ReactiveProperty <float>(orbit.Distance.Value),
Phase = orbit.Phase + phase
};
pack.Orbits.Add(turretOrbit);
var turret = loadoutGenerator.GenerateTurretLoadout();
turret.Orbit = turretOrbit.ID;
pack.Entities.Add(turret);
}
void PlaceTurrets(OrbitData orbit, LoadoutGenerator loadoutGenerator, int count)
{
for (int t = 0; t < count; t++)
{
var dist = t / 2;
if (t % 2 == 0)
{
dist = -dist;
}
PlaceTurret(orbit, loadoutGenerator, dist);
}
}
for (var i = 0; i < storyStations.Length; i++)
{
var story = storyStations[i];
var orbit = selectedStationOrbits[i];
var lagrangeOrbit = CreateLagrangeOrbit(orbit);
var station = GetLoadoutGenerator(story.Faction).GenerateStationLoadout();
station.Orbit = lagrangeOrbit.ID;
station.SecurityLevel = story.Security;
station.SecurityRadius = pack.Radius;
station.Story = i;
pack.Entities.Add(station);
PlaceTurrets(lagrangeOrbit, GetLoadoutGenerator(story.Faction), story.Turrets);
}
for (var i = storyStations.Length; i < selectedStationOrbits.Length; i++)
{
var orbit = selectedStationOrbits[i];
var security = (SecurityLevel)((int)((1f - pow(random.NextFloat(), factionPresence / 2f)) * 3f));
var lagrangeOrbit = CreateLagrangeOrbit(orbit);
var station = GetLoadoutGenerator(nearestFaction).GenerateStationLoadout();
station.Orbit = lagrangeOrbit.ID;
station.SecurityLevel = security;
station.SecurityRadius = pack.Radius;
pack.Entities.Add(station);
PlaceTurrets(lagrangeOrbit, GetLoadoutGenerator(nearestFaction), 2);
}
var enemyCount = (int)(random.NextFloat() * factionPresence * 2) + stationCount;
for (int i = 0; i < enemyCount; i++)
{
pack.Entities.Add(GetLoadoutGenerator(nearestFaction).GenerateShipLoadout());
}
return(pack);
}
public StarSystemData LoadStarSystemData(string path, bool isScene)
{
//
XmlDocument doc = new XmlDocument();
string file = File.ReadAllText(path);
try
{
doc.LoadXml(file);
}
catch (XmlException)
{
return(null);
}
XmlNode systemNode = doc.GetElementsByTagName("system")[0];
XmlAttributeCollection systemAttrs = systemNode.Attributes;
string systemID = systemAttrs["id"].Value.ToString();
string systemName = systemAttrs["displayname"].Value.ToString();
Transform origin = null;
if (isScene)
{
origin = GameObject.Find("Origin").transform;
}
StarSystemData systemData = new StarSystemData(systemID, systemName);
systemData.SystemID = systemID;
XmlNodeList systemContent = systemNode.ChildNodes;
foreach (XmlNode node in systemContent)
{
if (node.Name == "systemlocation")
{
Vector3 location = location = DBManager.ParseXmlVector3(node.FirstChild);
systemData.Location = new RelLoc(Vector3.zero, location, null);
}
if (node.Name == "ambience")
{
XmlNodeList content = node.ChildNodes;
foreach (XmlNode subnode in content)
{
if (subnode.Name == "skybox")
{
string skyboxName = node.InnerText;
systemData.SkyboxName = skyboxName;
}
if (subnode.Name == "ambientcolor")
{
XmlNode colorNode = subnode.FirstChild;
systemData.AmbientColor = DBManager.ParseXmlColorNode(colorNode);
}
}
}
if (node.Name == "origin")
{
Vector3 originLoc = DBManager.ParseXmlVector3(node.FirstChild);
systemData.OriginPosition = originLoc;
if (isScene)
{
origin.position = originLoc;
}
}
if (node.Name == "sun")
{
string sunID = "";
string name = "";
float intensity = 0;
Vector3 scale = Vector3.zero;
Vector3 location = Vector3.zero;
Color color = Color.black;
SunData sunData = new SunData();
XmlNodeList content = node.ChildNodes;
foreach (XmlNode subnode in content)
{
if (subnode.Name == "id")
{
sunID = subnode.InnerText;
}
if (subnode.Name == "displayname")
{
name = subnode.InnerText;
}
if (subnode.Name == "location")
{
location = systemData.OriginPosition + DBManager.ParseXmlVector3(subnode.FirstChild);
}
if (subnode.Name == "scale")
{
scale = DBManager.ParseXmlVector3(subnode.FirstChild);
}
if (subnode.Name == "sunlight")
{
XmlAttributeCollection sunlightAttr = subnode.Attributes;
intensity = Convert.ToSingle(sunlightAttr["intensity"].Value);
XmlNode colorNode = subnode.FirstChild;
color = DBManager.ParseXmlColorNode(colorNode);
}
}
sunData.ID = sunID;
sunData.DisplayName = name;
sunData.Location = new RelLoc(systemData.OriginPosition, location, origin);
sunData.Scale = scale;
sunData.Color = color;
sunData.Intensity = intensity;
systemData.Suns.Add(sunData);
}
if (node.Name == "planet")
{
string planetID = "";
string name = "";
Vector3 scale = Vector3.zero;
Vector3 location = Vector3.zero;
PlanetData planetData = new PlanetData();
XmlNodeList content = node.ChildNodes;
foreach (XmlNode subnode in content)
{
if (subnode.Name == "id")
{
planetID = subnode.InnerText;
}
if (subnode.Name == "displayname")
{
name = subnode.InnerText;
}
if (subnode.Name == "location")
{
location = systemData.OriginPosition + DBManager.ParseXmlVector3(subnode.FirstChild);
}
if (subnode.Name == "scale")
{
scale = DBManager.ParseXmlVector3(subnode.FirstChild);
}
}
planetData.ID = planetID;
planetData.DisplayName = name;
planetData.Location = new RelLoc(systemData.OriginPosition, location, origin);
planetData.OriginalScale = scale;
systemData.Planets.Add(planetData);
}
if (node.Name == "station")
{
string stationID = "";
string name = "";
string stationType = "";
Vector3 location = Vector3.zero;
Vector3 eulerAngles = Vector3.zero;
XmlNodeList content = node.ChildNodes;
string targetSystem = "";
string exitGateID = "";
List <string> neighborIDs = new List <string>();
Vector3 spawnDisposition = Vector3.zero;
foreach (XmlNode subnode in content)
{
if (subnode.Name == "id")
{
stationID = subnode.InnerText;
}
if (subnode.Name == "displayname")
{
name = subnode.InnerText;
}
if (subnode.Name == "stationtype")
{
stationType = subnode.InnerText;
}
if (subnode.Name == "location")
{
location = systemData.OriginPosition + DBManager.ParseXmlVector3(subnode.FirstChild);
}
if (subnode.Name == "eulerangles")
{
eulerAngles = DBManager.ParseXmlVector3(subnode.FirstChild);
}
if (subnode.Name == "targetsystem")
{
targetSystem = subnode.InnerText;
}
if (subnode.Name == "exitgateid")
{
exitGateID = subnode.InnerText;
}
if (subnode.Name == "navneighbor")
{
neighborIDs.Add(subnode.InnerText);
}
if (subnode.Name == "spawndisposition")
{
spawnDisposition = DBManager.ParseXmlVector3(subnode.FirstChild);
}
}
if (stationType == "JumpGate")
{
JumpGateData jumpGateData = new JumpGateData();
jumpGateData.ID = stationID;
jumpGateData.DisplayName = name;
jumpGateData.TargetSystem = targetSystem;
jumpGateData.ExitGateID = exitGateID;
jumpGateData.Location = new RelLoc(systemData.OriginPosition, location, origin);
jumpGateData.EulerAngles = eulerAngles;
jumpGateData.NeighborIDs = neighborIDs;
jumpGateData.NavNodeType = NavNodeType.JumpGate;
jumpGateData.SystemID = systemID;
jumpGateData.SpawnDisposition = spawnDisposition;
systemData.JumpGates.Add(jumpGateData);
systemData.ChildNodes.Add(jumpGateData);
systemData.NeighborIDs.Add(targetSystem);
}
else if (stationType == "Station")
{
StationData stationData = new StationData();
stationData.DisplayName = name;
stationData.ID = stationID;
stationData.Location = new RelLoc(systemData.OriginPosition, location, origin);
stationData.EulerAngles = eulerAngles;
stationData.NeighborIDs = neighborIDs;
stationData.NavNodeType = NavNodeType.Station;
stationData.SystemID = systemID;
systemData.Stations.Add(stationData);
systemData.ChildNodes.Add(stationData);
}
}
if (node.Name == "tradelane")
{
string stationID = "";
string displayName = "";
Vector3 location = Vector3.zero;
Vector3 eulerAngles = Vector3.zero;
XmlNodeList content = node.ChildNodes;
string terminal = "";
string neighborA = "";
string neighborB = "";
List <string> neighborIDs = new List <string>();
foreach (XmlNode subnode in content)
{
if (subnode.Name == "id")
{
stationID = subnode.InnerText;
}
if (subnode.Name == "displayname")
{
displayName = subnode.InnerText;
}
if (subnode.Name == "location")
{
location = systemData.OriginPosition + DBManager.ParseXmlVector3(subnode.FirstChild);
}
if (subnode.Name == "eulerangles")
{
eulerAngles = DBManager.ParseXmlVector3(subnode.FirstChild);
}
if (subnode.Name == "terminal")
{
terminal = subnode.InnerText;
}
if (subnode.Name == "neighbor_a")
{
neighborA = subnode.InnerText;
if (neighborA != "NULL")
{
neighborIDs.Add(neighborA);
}
}
if (subnode.Name == "neighbor_b")
{
neighborB = subnode.InnerText;
if (neighborB != "NULL")
{
neighborIDs.Add(neighborB);
}
}
if (subnode.Name == "navneighbor")
{
neighborIDs.Add(subnode.InnerText);
}
}
TradelaneData tradelaneData = new TradelaneData();
tradelaneData.ID = stationID;
tradelaneData.DisplayName = displayName;
tradelaneData.IsTerminalAorB = Convert.ToInt32(terminal);
tradelaneData.NeighborAID = neighborA;
tradelaneData.NeighborBID = neighborB;
tradelaneData.Location = new RelLoc(systemData.OriginPosition, location, origin);
tradelaneData.EulerAngles = eulerAngles;
tradelaneData.NeighborIDs = neighborIDs;
tradelaneData.NavNodeType = NavNodeType.Tradelane;
tradelaneData.SystemID = systemID;
systemData.Tradelanes.Add(tradelaneData);
systemData.ChildNodes.Add(tradelaneData);
}
}
return(systemData);
}
public Sun(PlanetSettings settings, SunData data, Orbit orbit) : base(settings, data, orbit)
{
LightRadius = new ReadOnlyReactiveProperty <float>(
data.Mass.CombineLatest(data.LightRadiusMultiplier,
(mass, radius) => settings.LightRadius.Evaluate(mass) * radius));
}
public void SetData(SunData data)
{
transform.rotation = data.rotation;
transform.position = data.position;
transform.localScale = data.scale;
}
