private Point3 a()
{
float distance = Point3.Distance(this.Position, Center.Position);
Point3 x = new Point3();
x.assign(Position - Center.Position);
float fak = (float)(-Center.G * Center.Mass / Math.Pow(distance, 3));
return(x * fak);
}
/// <summary>
/// Beschleunigung Richtung Bezugsobjekt
/// </summary>
/// <param name="o">Bezugsobjekt</param>
/// <returns></returns>
private Point3 a(o2Object o)
{
float distance = Point3.Distance(this.Position, o.Position);
Point3 x = new Point3();
x.assign(Position - o.Position);
float fak = (float)(-PlanetAdvanced2.G * o.Mass / Math.Pow(distance, 3));
return(x * fak);
}
private void ThreadTick()
{
float distance;
float ri;
float rj;
oObject oi;
oObject oj;
lock (Objects)
{
foreach (oObject o in Objects)
{
o.MoveObject();
}
for (int i = 0; i < Objects.Count - 1; i++)
{
for (int j = i + 1; j < Objects.Count; j++)
{
oi = Objects[i];
oj = Objects[j];
distance = Point3.Distance(oi.Position, oj.Position);
ri = oi.Size;
rj = oj.Size;
if (ri + rj > distance)
{
if (Objects[i] == Sun)
{
Sun.Mass += oj.Mass;
Objects.Remove(oj);
break;
}
else
{
if (Objects[j] == Sun)
{
Sun.Mass += oi.Size;
;
Objects.Remove(oi);
break;
}
else
{
Objects.Remove(oi);
Objects.Remove(oj);
break;
}
}
}
}
}
}
}
/// <summary>
/// Fügt einem Zentralobjekt untergeordnete es umkreisende Objekte hinzu
/// </summary>
/// <param name="_ZentralObjekt">Dies ist das Zentralobjekt um welches die hinzugefügten kreisen sollen</param>
/// <param name="cnt">Anzahl der das Zentralobjekt umkreisenden Objekte</param>
private void AddPlanet(o2Object _ZentralObjekt, int cnt)
{
bool SunIsParent = _ZentralObjekt is o2Sun; // ist das Zentralobjekt eine Sonne?
for (int i = 0; i < cnt; i++)
{
float Mass = 1f;
if (SunIsParent) // Planet
{
int ps = rnd.Next(28, 30);
Mass = (float)rnd.NextDouble() * (float)Math.Pow(10, ps) * PlanetAdvanced2.UniFak; // Größe Abhängig von Basisgröße der Planeten
}
else // Mond.
{
float f = rnd.Next(80, 1000); // Faktor um wie viel der Mond kleiner sein soll, als der Körper um den er kreist.
Mass = _ZentralObjekt.Mass / f; // Erd-Mond ist ca. 1/81 der Erdmasse. Da er der Größte im Sonnensystem ist, nehm ich das Verhältnis als max. an.
}
Point3 Pos = RndPosToSun(_ZentralObjekt, false, SunIsParent); // Position soll relativ zum Zentralkörper sein
float distance = Point3.Distance(_ZentralObjekt.Position, Pos);
Point3 Dir = MM.MatDotPoint(RotMatrix90z(), Pos - _ZentralObjekt.Position); // Richtung 90Grad zum Sonnenwinkel
Dir.Normalize();
Dir *= (float)Math.Sqrt(PlanetAdvanced2.G * _ZentralObjekt.Mass / distance); // *fak(); // 1. kosmische Geschwindigkeit (Rotation auf Kreisbahn).
Dir += Dir * ((float)rnd.NextDouble() / 10f); //* fak()); // ein wenig Varianz, um es interessannt zu machen.
Dir += _ZentralObjekt.Direction; // Bewegung der Bezugssonne draufrechnen, damit Sich Planet mitbewegt.
float[] Color = { (float)rnd.NextDouble(), (float)rnd.NextDouble(), (float)rnd.NextDouble() }; // Farbe ist zufällig
o2Object p = new o2Object(Pos, Dir, Mass, Color, null);
Objects.Add(p);
getList().Add(p);
if (SunIsParent)
{
int c = rnd.Next(0, 4);
AddPlanet(p, c);
}
}
}
/// <summary>
/// Eine um die Hauptsonne kreisende Sonne wird erstellt. Diese kann auch größer sein, was sie aber nicht zur Hauptsonne macht.
/// </summary>
private void AddSun()
{
if (suncount < _Light.Length - 1)
{
float Massfak = (float)rnd.Next(1, 3) * 5 * PlanetAdvanced2.initSunMass;
float Mass = (float)rnd.NextDouble() * Massfak;
Point3 Pos = RndPosToSun(Sun, true, false); // Zufällige Position bezgl der Sonne
Point3 Dir = MM.MatDotPoint(RotMatrix90z(), Pos - Sun.Position); // Richtung 90Grad zum SonnenVektor
Dir.Normalize(); // BewegungsRichtung normalisieren.
//Dir *= (float)((rnd.NextDouble() * 3) + 2f) * 40f; // Speed zurechnen. Kosmische Gesch. schlug hier immer fehl.
float distance = Point3.Distance(Sun.Position, Pos);
Dir *= (float)Math.Sqrt(G * Sun.Mass / distance); // *fak(); // 1. kosmische Geschwindigkeit (Rotation auf Kreisbahn).
Dir += Sun.Direction; // Bewegung der Bezugssonne draufrechnen, damit Sich Planet mitbewegt.
float[] Color = { (float)rnd.NextDouble(), (float)rnd.NextDouble(), (float)rnd.NextDouble() };
suncount++; // Sonnenzähler erhöhen. (wichtig für Lichtquellen);
Objects.Add(new o2Sun(Pos, Dir, Mass, Color, _Light[suncount]));
}
}
/// <summary>
/// eine Simulationsperiode
/// </summary>
private void ThreadTick()
{
float distance;
float ri;
float rj;
o2Object oi;
o2Object oj;
try
{
#region Bewegung
foreach (o2Object o in Objects)
{
o.MoveObject(Objects);
if (showTrace)
{
o.Trace();
}
}
#endregion
}
catch
{ }
try // Wegen Threading kommt es gern zu Fehlern beim Entfernen von Objekten. Das wird hier abgefangen.
{ // ist unsauber und langsamer, ich weiß.
#region Kollision
// Kollisionsabfrage Schwereres Objekt bekommt Masse von leichterem Objekt
// und der Impuls des kleineren wird auf den größeren gerechnet.
// Sonne wird nicht zerstört, da sie Lichtquelle ist.
for (int i = 0; i < Objects.Count - 1; i++)
{
for (int j = i + 1; j < Objects.Count; j++)
{
oi = Objects[i];
oj = Objects[j];
distance = Point3.Distance(oi.Position, oj.Position);
Point3 impulse = new Point3();
ri = oi.Size;
rj = oj.Size;
if (ri + rj > distance) // Objekte kollidieren ( Summe der Radien > Abstand )
{
impulse = (oi.Direction * oi.Mass) + (oj.Direction * oj.Mass);
if (Objects[i] == Sun) // erstes Objekt ist die HauptSonne - Hauptsonne soll bleiben.
{
Sun.Mass += oj.Mass;
Sun.Direction = impulse / Sun.Mass;
Objects.Remove(oj);
ConvertPlanet2Sun(oi);
break;
}
else
{
if (Objects[j] == Sun) // zweites Objekt ist die Hauptsonne - Hauptsonne soll bleiben
{
Sun.Mass += oi.Mass;
Sun.Direction = impulse / Sun.Mass;
Objects.Remove(oi);
ConvertPlanet2Sun(oj);
break;
}
else // Kein Objekt ist die Hauptsonne.
{
if (oi.Mass > oj.Mass)
{
oi.Mass += oj.Mass;
oi.Direction = impulse / oi.Mass;
Objects.Remove(oj);
ConvertPlanet2Sun(oi);
break;
}
else
{
oj.Mass += oi.Mass;
oj.Direction = impulse / oj.Mass;
Objects.Remove(oi);
ConvertPlanet2Sun(oj);
break;
}
}
}
}
}
}
#endregion
}
catch
{ }
try // Wegen Threading kommt es gern zu Fehlern beim Entfernen von Objekten. Das wird hier abgefangen.
{ // ist unsauber und langsamer, ich weiß.
#region zu weit vom Ursprung entfernte Objekte entfernen
for (int i = Objects.Count - 1; i >= 0; i--)
{
o2Object o = Objects[i];
distance = Point3.Distance(new Point3(), o.Position);
if (distance > 1000000)
{
if (o == Sun)
{
Sun.Direction = new Point3();
Sun.Position = new Point3();
}
else
{
Objects.Remove(o);
}
}
}
#endregion
}
catch (Exception)
{ }
if (Sun != null && centered)
{
resetSun();
}
}
private void ThreadTick()
{
float distance;
float ri;
float rj;
oDBObject oi;
oDBObject oj;
lock (Objects)
{
foreach (oDBObject o in Objects)
{
o.MoveObject();
}
for (int i = 0; i < Objects.Count - 1; i++)
{
for (int j = i + 1; j < Objects.Count; j++)
{
oi = Objects[i];
oj = Objects[j];
distance = Point3.Distance(oi.Position, oj.Position);
ri = oi.Size;
rj = oj.Size;
if (ri + rj > distance)
{
if (Objects[i] == Sun)
{
Sun.Mass += oj.Mass;
Objects.Remove(oj);
break;
}
else
{
if (Objects[j] == Sun)
{
Sun.Mass += oi.Size;
;
Objects.Remove(oi);
break;
}
else
{
Objects.Remove(oi);
Objects.Remove(oj);
break;
}
}
}
}
}
try // Wegen Threading kommt es gern zu Fehlern beim Entfernen von Objekten. Das wird hier abgefangen.
{ // ist unsauber und langsamer, ich weiß.
#region zu weit von der Hauptsonne entfernte Objekte entfernen
for (int i = Objects.Count - 1; i >= 0; i--)
{
oDBObject o = Objects[i];
distance = Point3.Distance(Sun.Position, o.Position);
if (distance > 300000)
{
Objects.Remove(o);
}
}
#endregion
}
catch (Exception)
{ }
}
}
