// Use this for initialization
void Start()
{
backbuffer = new byte[ysize * xsize * 3];
tex = new Texture2D(xsize, ysize, TextureFormat.RGB24, false);
tex.filterMode = FilterMode.Point;
quadRenderer.material.mainTexture = tex;
offsetX = xsize / 2;
offsetY = ysize / 2;
MyMesh = new Mesh(new Vector3(0, 0, 0));
for (int i = 0; i < numberOfStars; i++)
{
StarClass starClass = new StarClass(new Vector3(Random.Range(-128, 128), Random.Range(-128, 128),
Random.Range(5, 10)));
MyMesh.Vertexes.Add(starClass);
}
MyMesh.Vertexes[0].LocalPosition = new Vector3(-20, 20, 20);
MyMesh.Vertexes[1].LocalPosition = new Vector3(20, 20, 20);
MyMesh.Vertexes[2].LocalPosition = new Vector3(-20, 20, 10);
MyMesh.Vertexes[3].LocalPosition = new Vector3(20, 20, 10);
MyMesh.Vertexes[4].LocalPosition = new Vector3(-20, -20, 20);
MyMesh.Vertexes[5].LocalPosition = new Vector3(20, -20, 20);
MyMesh.Vertexes[6].LocalPosition = new Vector3(-20, -20, 10);
MyMesh.Vertexes[7].LocalPosition = new Vector3(20, -20, 10);
}
public StarScannedEvent(DateTime timestamp, string name, string stellarclass, decimal solarmass, decimal radius, decimal absolutemagnitude, long age, decimal temperature, decimal distancefromarrival, decimal?orbitalperiod, decimal rotationperiod, decimal?semimajoraxis, decimal?eccentricity, decimal?orbitalinclination, decimal?periapsis, List <Ring> rings) : base(timestamp, NAME)
{
this.name = name;
this.stellarclass = stellarclass;
this.solarmass = solarmass;
this.radius = radius;
this.absolutemagnitude = absolutemagnitude;
this.age = age;
this.temperature = temperature;
this.distancefromarrival = distancefromarrival;
this.orbitalperiod = orbitalperiod;
this.rotationperiod = rotationperiod;
this.semimajoraxis = semimajoraxis;
this.eccentricity = eccentricity;
this.orbitalinclination = orbitalinclination;
this.periapsis = periapsis;
this.rings = rings;
StarClass starClass = StarClass.FromName(this.stellarclass);
if (starClass != null)
{
this.massprobability = sanitiseCP(starClass.stellarMassCP(solarmass));
this.solarradius = StarClass.solarradius(radius);
this.radiusprobability = sanitiseCP(starClass.stellarRadiusCP(this.solarradius));
this.luminosity = StarClass.luminosity(absolutemagnitude);
this.luminosityprobability = sanitiseCP(starClass.luminosityCP(this.luminosity));
// TODO remove when temperature is in journal
this.temperature = StarClass.temperature(luminosity, this.radius);
this.chromaticity = starClass.chromaticity;
}
}
public static StarData GetData(StarClass starClass)
{
switch (starClass)
{
case StarClass.Random:
return(GetData());
case StarClass.O:
return(StarData.O);
case StarClass.B:
return(StarData.B);
case StarClass.A:
return(StarData.A);
case StarClass.F:
return(StarData.F);
case StarClass.G:
return(StarData.G);
case StarClass.K:
return(StarData.K);
case StarClass.M:
return(StarData.M);
default:
break;
}
return(null);
}
private async void Star_Click(object sender, RoutedEventArgs e)
{
//判断是否登录了某个站点，可能也得用传参的方式
// var hashpass =HttpHelper.Hashpass(SettingHelper.UserPass_Yande);
if (SettingHelper.IsLoagin_Yande == "1")
{
if (is_favourite == true)
{
Star.IsEnabled = false;
await StarClass.Setfavourite(imgid, SettingHelper.Username_Yande, pass_hash, 2, CS.apiset.apiurisave.YandeHost);
//存在不执行的问题，待查
is_favourite = false;
Star.Icon = new SymbolIcon(Symbol.OutlineStar);
Star.Label = "收藏";
Star.IsEnabled = true;
}
else
{
Star.IsEnabled = false;
await StarClass.Setfavourite(imgid, SettingHelper.Username_Yande, pass_hash, 3, CS.apiset.apiurisave.YandeHost);
is_favourite = true;
Star.Icon = new SymbolIcon(Symbol.SolidStar);
Star.Label = "取消收藏";
Star.IsEnabled = true;
}
}
else
{
await new MessageDialog("请先登录喵~").ShowAsync();
}
}
public void Generate(Enum.Itemtype item)
{
switch (item)
{
case Enum.Itemtype.Star:
IItem star = new StarClass(Mygame, new Vector2(rectangle.X, rectangle.Y));
Mygame.World.AddItem(star);
break;
case Enum.Itemtype.GreenMushroom:
IItem GreenMushroom = new GreenMushroomClass(Mygame, new Vector2(rectangle.X, rectangle.Y));
Mygame.World.AddItem(GreenMushroom);
break;
case Enum.Itemtype.RedMushroom:
IItem RedMushroom = new RedMushroomClass(Mygame, new Vector2(rectangle.X, rectangle.Y));
Mygame.World.AddItem(RedMushroom);
break;
case Enum.Itemtype.Coin:
IItem Coin = new CoinClass(Mygame, new Vector2(rectangle.X, rectangle.Y));
Mygame.World.AddItem(Coin);
break;
case Enum.Itemtype.Flower:
IItem Flower = new FlowerClass(Mygame, new Vector2(rectangle.X, rectangle.Y));
Mygame.World.AddItem(Flower);
break;
}
this.ItemNumber--;
}
public StarSystem(
Point coordinates,
StarClass starClass)
{
Coordinates = coordinates;
StarClass = starClass;
}
private static StarClass GetStarClass(double mass, double size, int temperature, double luminosity)
{
StarClass starClass = StarClass.A;
if (temperature >= 30000 && luminosity >= 30000 && mass >= 16 && size >= 6.6)
{
starClass = StarClass.O;
}
else if ((temperature >= 10000 && temperature <= 30000) && (luminosity >= 25 && luminosity <= 30000) && (mass >= 2.1 && mass <= 16) && (size >= 1.8 && size <= 6.6))
{
starClass = StarClass.B;
}
else if ((temperature >= 7500 && temperature <= 10000) && (luminosity >= 5 && luminosity <= 25) && (mass >= 1.4 && mass <= 2.1) && (size >= 1.4 && size <= 1.8))
{
starClass = StarClass.A;
}
else if ((temperature >= 6000 && temperature <= 7500) && (luminosity >= 1.5 && luminosity <= 5) && (mass >= 1.04 && mass <= 1.4) && (size >= 1.15 && size <= 1.4))
{
starClass = StarClass.F;
}
else if ((temperature >= 5200 && temperature <= 6000) && (luminosity >= 0.6 && luminosity <= 1.5) && (mass >= 0.8 && mass <= 1.04) && (size >= 0.96 && size <= 1.15))
{
starClass = StarClass.G;
}
else if ((temperature >= 3700 && temperature <= 5200) && (luminosity >= 0.08 && luminosity <= 0.6) && (mass >= 0.45 && mass <= 0.8) && (size >= 0.7 && size <= 0.96))
{
starClass = StarClass.K;
}
else if ((temperature >= 2400 && temperature <= 3700) && luminosity <= 0.08 && (mass >= 0.08 && mass <= 0.45) && size <= 0.7)
{
starClass = StarClass.M;
}
return(starClass);
}
public Star(string name, float mass, float size, int temp, float luminosity)
{
this.StarName = name;
StarMass = mass;
StarSize = size / 2;
StarTemp = temp;
StarLuminosity = luminosity;
if (StarTemp >= 30000 &&
StarLuminosity >= 30000 &&
StarMass >= 16 &&
StarSize >= 6.6)
{
StarClass = StarClass.O;
}
else if (StarTemp >= 10000 &&
StarLuminosity >= 25 &&
StarMass >= 2.1 &&
StarSize >= 1.8)
{
StarClass = StarClass.B;
}
else if (StarTemp >= 7500 &&
StarLuminosity >= 5 &&
StarMass >= 1.4 &&
StarSize >= 1.4)
{
StarClass = StarClass.A;
}
else if (StarTemp >= 6000 &&
StarLuminosity >= 1.5 &&
StarMass >= 1.04 &&
StarSize >= 1.15)
{
StarClass = StarClass.F;
}
else if (StarTemp >= 5200 &&
StarLuminosity >= 0.6 &&
StarMass >= 0.8 &&
StarSize >= 0.96)
{
StarClass = StarClass.G;
}
else if (StarTemp >= 3700 &&
StarLuminosity > 0.08 &&
StarMass >= 0.45 &&
StarSize > 0.7)
{
StarClass = StarClass.K;
}
else if (StarTemp >= 2400 &&
StarLuminosity <= 0.08 &&
StarMass >= 0.08 &&
StarSize <= 0.7)
{
StarClass = StarClass.M;
}
this.Planets = new List <Planet>();
}
public StarCluster()
{
stars = new StarClass[6];
for (int i=0;i<6;i++){
stars[i] = new StarClass();
}
}
public Star()
{
float classChance = Random.Range(0f, 100f);
if (classChance < 3f) Class = StarClass.O;
else if (classChance < 10) Class = StarClass.B;
else if (classChance < 20) Class = StarClass.A;
else if (classChance < 35) Class = StarClass.F;
else if (classChance < 50) Class = StarClass.G;
else if (classChance < 75) Class = StarClass.K;
else Class = StarClass.M;
switch (Class) {
case StarClass.O:
SurfaceTemperature = Random.Range(30000f, 50000f);
SolarMass = Random.Range(16f, 50f);
SolarRadius = Random.Range(6.6f, 15f);
break;
case StarClass.B:
SurfaceTemperature = Random.Range(10000f, 30000f);
SolarMass = Random.Range(2.1f, 16f);
SolarRadius = Random.Range(1.8f, 6.6f);
break;
case StarClass.A:
SurfaceTemperature = Random.Range(7500f, 10000f); // 7k - 2 AU habitable
SolarMass = Random.Range(1.4f, 2.1f);
SolarRadius = Random.Range(1.4f, 1.8f);
break;
case StarClass.F:
SurfaceTemperature = Random.Range(6000f, 7500f); // 6k - 1.5 AU habitable
SolarMass = Random.Range(1.04f, 1.4f);
SolarRadius = Random.Range(1.15f, 1.4f);
break;
case StarClass.G:
SurfaceTemperature = Random.Range(5200f, 6000f);
SolarMass = Random.Range(0.8f, 1.04f);
SolarRadius = Random.Range(0.96f, 1.15f);
break;
case StarClass.K:
SurfaceTemperature = Random.Range(3700f, 5200f);
SolarMass = Random.Range(0.45f, 0.8f);
SolarRadius = Random.Range(0.7f, 0.96f);
break;
case StarClass.M:
SurfaceTemperature = Random.Range(2400f, 3700f); // 3k - 0.2 AU habitable
SolarMass = Random.Range(0.08f, 0.45f);
SolarRadius = Random.Range(0.4f, 0.7f);
break;
}
float a = Mathf.Clamp(20 - SolarMass, 5, 20) / 5f;
SolarLuminosity = Mathf.Pow(SolarMass, a);
HabitableZoneCenter = 0.016f * Mathf.Pow((SurfaceTemperature/1000f), 2) + 0.28f * (SurfaceTemperature/1000f);
if (HabitableZoneCenter < 0.1f) HabitableZoneCenter = 0.1f;
Debug.Log(this.ToString());
}
public void TestStarSol()
{
StarScannedEvent scan = new StarScannedEvent(DateTime.Now, "Sol", "G", 1, 1, 4.83M, 5400000000, 300, 0, 10, 10, 0, 0, 0, 0, null);
decimal solLuminosity = StarClass.luminosity(scan.absolutemagnitude);
StarClass starClass = StarClass.FromName(scan.stellarclass);
decimal massChance = starClass.stellarMassCP(scan.solarmass);
decimal radiusChance = starClass.stellarRadiusCP(scan.radius);
decimal luminosityChance = starClass.luminosityCP(solLuminosity);
}
public void TestJournalStarScan2()
{
string line = @"{ ""timestamp"":""2016-10-28T12:07:09Z"", ""event"":""Scan"", ""BodyName"":""Col 285 Sector CG-X d1-44"", ""DistanceFromArrivalLS"":0.000000, ""StarType"":""TTS"", ""StellarMass"":0.808594, ""Radius"":659162816.000000, ""AbsoluteMagnitude"":6.411560, ""Age_MY"":154, ""SurfaceTemperature"":4124.000000, ""RotationPeriod"":341417.281250, ""Rings"":[ { ""Name"":""Col 285 Sector CG-X d1-44 A Belt"", ""RingClass"":""eRingClass_Rocky"", ""MassMT"":1.1625e+13, ""InnerRad"":1.0876e+09, ""OuterRad"":2.4192e+09 } ] }";
StarScannedEvent theEvent = (StarScannedEvent)JournalMonitor.ParseJournalEntry(line);
Assert.IsNotNull(theEvent);
Assert.AreEqual(theEvent.radius, (decimal)659162816.0);
Assert.AreEqual(theEvent.solarradius, StarClass.solarradius((decimal)659162816.000000));
Assert.AreEqual(0.94775, (double)theEvent.solarradius, 0.01);
}
public static Color GetStarClassColor(string starClass)
{
var kind = StarClass.GetKind(starClass, out var baseClass);
if (kind != StarClass.Kind.Unknown && _baseStarClass.TryGetValue(baseClass, out var res))
{
return(res);
}
return(Color.Black);
}
public static bool IsOneOf(this StarClass starClass, params StarClass[] starClasses)
{
foreach (var oneOf in starClasses)
{
if (starClass == oneOf)
{
return(true);
}
}
return(false);
}
public static Color GetStarClassColor(string starClass)
{
StarClass.GetKind(starClass, out var baseClass);
if (_baseStarClass.TryGetValue(baseClass, out var res))
{
return(res);
}
return(Color.Black);
}
public void ProcessEventForFSD(JournalEvent journalEvent)
{
switch (journalEvent.@event)
{
case EventType.StartJump:
StartJump startJump = (StartJump)journalEvent;
if (startJump.JumpType == JumpType.Hyperspace)
{
fsdState = FSDState.CountdownHyperspace;
try
{
jumpStarClass = (StarClass)Enum.Parse(typeof(StarClass), startJump.StarClass, true);
}
catch (Exception e)
{
jumpStarClass = StarClass.K;
}
}
else
{
fsdState = FSDState.CountdownSupercruise;
jumpStarClass = StarClass.None;
SetFsdWaitingSupercruise(true);
}
SetFsdWaitingCooldown(true);
fsdChargeStartTime = Utils.Time.GetMillisecondsSinceEpoch();
break;
case EventType.SupercruiseEntry:
ResetFsd();
SetFsdWaitingCooldown(false);
break;
case EventType.SupercruiseExit:
ResetFsd();
SetFsdWaitingCooldown(true);
break;
case EventType.FSDJump:
ResetFsd();
SetFsdWaitingCooldown(true);
ExitStarClass = jumpStarClass;
break;
case EventType.Music:
if (fsdState == FSDState.CountdownHyperspace && ((Music)journalEvent).MusicTrack.Equals("NoTrack"))
{
ResetFsd();
fsdState = FSDState.InHyperspace;
}
break;
}
}
public void StarClassIsParsedCorrectly(string starClass, string expectedBaseClass, StarClass.Kind expectedKind)
{
var entry = (StartJump)JsonConvert.DeserializeObject <JournalEntry>($"{{ \"event\":\"StartJump\", \"StarClass\":\"{starClass}\" }}");
Assert.Equal(starClass, entry.StarClass);
var kind = StarClass.GetKind(entry.StarClass, out var baseClass);
Assert.Equal(expectedBaseClass, baseClass);
Assert.Equal(expectedKind, kind);
}
public async void isfavourite(string pass_hash)
{
is_favourite = await StarClass.Isfavourite(imgid, SettingHelper.Username_Yande, pass_hash, CS.apiset.apiurisave.YandeHost);
if (is_favourite == true)
{
Star.Label = "取消收藏";
Star.Icon = new SymbolIcon(Symbol.SolidStar);
}
else
{
Star.Label = "收藏";
Star.Icon = new SymbolIcon(Symbol.OutlineStar);
}
}
public static void AddStar(string name, string galaxyName, string mass, string size, string temperature, string luminosity)
{
if (!GalaxyService.Galaxies.Exists(g => g.Name.ToUpper() == galaxyName.ToUpper()))
{
throw new Exception("Invalid Galaxy Name!!");
}
double result = 0;
if (!double.TryParse(mass, out result))
{
throw new Exception("Invalid Mass!!");
}
if (!double.TryParse(size, out result))
{
throw new Exception("Invalid Size!!");
}
int tempResult = 0;
if (!int.TryParse(temperature, out tempResult))
{
throw new Exception("Invalid Temperature!!");
}
if (!double.TryParse(luminosity, out result))
{
throw new Exception("Invalid Luminosity!!");
}
StarClass starClass = GetStarClass(Convert.ToDouble(mass), Convert.ToDouble(size), Convert.ToInt32(temperature), Convert.ToDouble(luminosity));
Star star = new Star()
{
Name = name,
GalaxyName = galaxyName,
Class = starClass,
Mass = Convert.ToDouble(mass),
Size = Convert.ToDouble(size),
Temperature = Convert.ToInt32(temperature),
Luminosity = Convert.ToDouble(luminosity),
};
Stars.Add(star);
}
private static HazardLevel GetHazardLevel(string starClass)
{
switch (StarClass.GetKind(starClass, out _))
{
case StarClass.Kind.MainSequence:
return(HazardLevel.Low);
case StarClass.Kind.Neutron:
case StarClass.Kind.WhiteDwarf:
case StarClass.Kind.BlackHole:
return(HazardLevel.High);
default:
return(HazardLevel.Medium);
}
}
public Star(
int Id,
string name,
StarClass starClass,
decimal luminosity,
decimal absoluteMagnitude,
decimal diameterInMeters,
Point3D location
)
{
this.Id = Id;
this.Name = name;
this.StarClass = starClass;
this.Luminosity = luminosity;
this.AbsoluteMagnitude = absoluteMagnitude;
this.DiameterInMeters = diameterInMeters;
this.Location = location;
this.Planets = new List <Planet>();
}
} // One of Basic, Detailed, NavBeacon, NavBeaconDetail
public StarScannedEvent(DateTime timestamp, string scantype, string name, string stellarclass, decimal solarmass, decimal radius, decimal absolutemagnitude, string luminosityclass, long age, decimal temperature, decimal distancefromarrival, decimal?orbitalperiod, decimal rotationperiod, decimal?semimajoraxis, decimal?eccentricity, decimal?orbitalinclination, decimal?periapsis, List <Ring> rings) : base(timestamp, NAME)
{
this.scantype = scantype;
this.name = name;
this.stellarclass = stellarclass;
this.solarmass = solarmass;
this.radius = radius;
this.absolutemagnitude = absolutemagnitude;
this.luminosityclass = luminosityclass;
this.age = age;
this.temperature = temperature;
this.distancefromarrival = distancefromarrival;
this.orbitalperiod = orbitalperiod;
this.rotationperiod = rotationperiod;
this.semimajoraxis = semimajoraxis;
this.eccentricity = eccentricity;
this.orbitalinclination = orbitalinclination;
this.periapsis = periapsis;
this.rings = rings;
solarradius = StarClass.solarradius(radius);
luminosity = StarClass.luminosity(absolutemagnitude);
StarClass starClass = StarClass.FromName(this.stellarclass);
if (starClass != null)
{
massprobability = StarClass.sanitiseCP(starClass.stellarMassCP(solarmass));
radiusprobability = StarClass.sanitiseCP(starClass.stellarRadiusCP(this.solarradius));
tempprobability = StarClass.sanitiseCP(starClass.tempCP(this.temperature));
ageprobability = StarClass.sanitiseCP(starClass.ageCP(this.age));
chromaticity = starClass.chromaticity.localizedName;
if (radius != 0 && temperature != 0)
{
// Minimum estimated single-star habitable zone (target black body temperature of 315°K / 42°C / 107°F or less)
estimatedhabzoneinner = StarClass.DistanceFromStarForTemperature(maxHabitableTempKelvin, Convert.ToDouble(radius), Convert.ToDouble(temperature));
this.estimatedhabzoneinner = estimatedhabzoneinner;
// Maximum estimated single-star habitable zone (target black body temperature of 223.15°K / -50°C / -58°F or more)
estimatedhabzoneouter = StarClass.DistanceFromStarForTemperature(minHabitableTempKelvin, Convert.ToDouble(radius), Convert.ToDouble(temperature));
this.estimatedhabzoneouter = estimatedhabzoneouter;
}
}
this.estimatedvalue = estimateValue(scantype == "Detailed" || scantype == "NavBeaconDetail");
}
private void RegenerateHyperspaceExitAnimation(StarClass starClass = StarClass.K)
{
if (starClass == hyperspace_exit_star)
{
return;
}
hypespace_exit_mix = new AnimationMix();
float startingX = Effects.canvas_width_center - 10;
Color hyperspaceExitColor = starColors.ContainsKey(starClass) ? starColors[starClass] : starColors[StarClass.K];
AnimationTrack star_entry = new AnimationTrack("Hyperspace exit", 2.0f);
star_entry.SetFrame(0.0f,
new AnimationFilledCircle(startingX, Effects.canvas_height_center, 0, hyperspaceExitColor, 1)
);
star_entry.SetFrame(1.0f,
new AnimationFilledCircle(startingX, Effects.canvas_height_center, Effects.canvas_biggest, hyperspaceExitColor, 1)
);
star_entry.SetFrame(1.2f,
new AnimationFilledCircle(startingX, Effects.canvas_height_center, Effects.canvas_biggest, hyperspaceExitColor, 1)
);
star_entry.SetFrame(2f,
new AnimationFilledCircle(startingX, Effects.canvas_height_center, Effects.canvas_biggest, Color.Empty, 1)
);
AnimationTrack star_entry_bg = new AnimationTrack("Hyperspace exit bg", 2f);
star_entry_bg.SetFrame(0.0f,
new AnimationFill(Color.Black)
);
star_entry_bg.SetFrame(1.2f,
new AnimationFill(Color.Black)
);
hypespace_exit_mix.AddTrack(star_entry_bg);
hypespace_exit_mix.AddTrack(star_entry);
}
public void Create()
{
if (Class == StarClass.Random)
{
Data = StarData.GetData();
}
else
{
Data = StarData.GetData(Class);
}
Data.Mutate();
float index = Random.Range(0.0f, 1f);
Data.Luminosity.RandomValue(index, Mathf.Lerp);
Data.Radius.RandomValue(index, Mathf.Lerp);
Data.Color.RandomValue(index, Color.Lerp);
Data.Mass.RandomValue(index, Mathf.Lerp);
this.Evolution = Data.EvolutionState;
this.Class = Data.StarClass;
Visualize();
DestroyPlanets();
EcoZone = Star.EcosphereZone(this);
}
public Star()
{
float classChance = Random.Range(0f, 100f);
if (classChance < 3f)
{
Class = StarClass.O;
}
else if (classChance < 10)
{
Class = StarClass.B;
}
else if (classChance < 20)
{
Class = StarClass.A;
}
else if (classChance < 35)
{
Class = StarClass.F;
}
else if (classChance < 50)
{
Class = StarClass.G;
}
else if (classChance < 75)
{
Class = StarClass.K;
}
else
{
Class = StarClass.M;
}
switch (Class)
{
case StarClass.O:
SurfaceTemperature = Random.Range(30000f, 50000f);
SolarMass = Random.Range(16f, 50f);
SolarRadius = Random.Range(6.6f, 15f);
break;
case StarClass.B:
SurfaceTemperature = Random.Range(10000f, 30000f);
SolarMass = Random.Range(2.1f, 16f);
SolarRadius = Random.Range(1.8f, 6.6f);
break;
case StarClass.A:
SurfaceTemperature = Random.Range(7500f, 10000f); // 7k - 2 AU habitable
SolarMass = Random.Range(1.4f, 2.1f);
SolarRadius = Random.Range(1.4f, 1.8f);
break;
case StarClass.F:
SurfaceTemperature = Random.Range(6000f, 7500f); // 6k - 1.5 AU habitable
SolarMass = Random.Range(1.04f, 1.4f);
SolarRadius = Random.Range(1.15f, 1.4f);
break;
case StarClass.G:
SurfaceTemperature = Random.Range(5200f, 6000f);
SolarMass = Random.Range(0.8f, 1.04f);
SolarRadius = Random.Range(0.96f, 1.15f);
break;
case StarClass.K:
SurfaceTemperature = Random.Range(3700f, 5200f);
SolarMass = Random.Range(0.45f, 0.8f);
SolarRadius = Random.Range(0.7f, 0.96f);
break;
case StarClass.M:
SurfaceTemperature = Random.Range(2400f, 3700f); // 3k - 0.2 AU habitable
SolarMass = Random.Range(0.08f, 0.45f);
SolarRadius = Random.Range(0.4f, 0.7f);
break;
}
float a = Mathf.Clamp(20 - SolarMass, 5, 20) / 5f;
SolarLuminosity = Mathf.Pow(SolarMass, a);
HabitableZoneCenter = 0.016f * Mathf.Pow((SurfaceTemperature / 1000f), 2) + 0.28f * (SurfaceTemperature / 1000f);
if (HabitableZoneCenter < 0.1f)
{
HabitableZoneCenter = 0.1f;
}
Debug.Log(this.ToString());
}
public ISprite GetSprite(StarClass starClass)
{
return(_starSprites[starClass]);
}
public void TestStarEravarenth()
{
decimal temp = StarClass.temperature(StarClass.luminosity(6.885925M), 526252032M);
Assert.AreEqual(4138, (int)temp);
}
