Pygame machen einen Kreis drehen um eine andere

Question

Ich möchte eine Art von Solarsystem in Pygame machen. Ich habe es geschafft, eine feste zu machen, aber ich dachte, es wäre interessanter, eins mit Planeten zu machen, die sich um die Sonne und die Monde um Planeten bewegen. Gibt es eine Möglichkeit, das zu tun (wenn möglich mit Pygame)?

Was würde Ich mag ist:

Sun = pygame.draw.circle(...) 
planet1 = pygame.draw.circle(...) 
etc. 

a = [planet1, planet2, ...] 

for p in a: 
    move p[2] to pos(x, y) 

Das ist, was ich denke, funktionieren würde, aber ich bin mir nicht sicher, wie es geht. Außerdem habe ich darüber nachgedacht, den alten Planeten zu löschen und einen neuen direkt daneben zu zeichnen, aber das Problem ist, dass ich zufällige Merkmale (wie Farben, Abstand zur Sonne, Anzahl der Planeten im System usw.) und es verwende müsste diese Eigenschaften beibehalten. Irgendwelche Ideen?

Vielen Dank im Voraus!

Answer 1

Koordinaten eines Planeten um die Sonne um einen Winkel in Bezug auf die X-Achse gedreht sind , wo r der Abstand zur Sonne ist, ist, dass theta Winkel und (a, b) sind die Koordinaten der Sonne. Zeichnen Sie Ihren Kreis zentriert um (x, y).

EDIT: allgemein elliptische Bahn:

Wo

r0 den Radius einer kreisförmigen Umlaufbahn mit dem gleichen Drehimpuls und e ist die „Exzentrizität "der Ellipse

Answer 2

Sie können die Gravitation mit Newtons Gesetz der universellen Gravitation und dem zweiten Newtonschen Gesetz implementieren, um die Beschleunigungen der Planeten zu erhalten. Gib jedem Planeten eine Anfangsposition, Geschwindigkeit und Masse. Beschleunigung ist Geschwindigkeitsänderung a = v * dt, Geschwindigkeit ist Veränderung in Position v = r * dt, also können wir integrieren, um Geschwindigkeit und Position zu finden.

allgemeine Gravitation: F = G * m1 * m2/r ** 2 wo F der Betrag der Kraft auf dem Objekt ist, G die Gravitationskonstante ist, und m1m2 sind die Massen der Objekte und r ist der Abstand zwischen den beiden Objekten.

Newtons zweites Gesetz: F = m1 * a wo ist die Beschleunigung.

dt = 0.01 # size of time step 
G = 100 # gravitational constant 

def calcGravity(sun, planet): 
    'Returns acceleration of planet with respect to the sun' 
    diff_x = sun.x - planet.x 
    diff_y = sun.y - planet.y 
    acceleration = G * sun.mass/(diff_x ** 2 + diff_y ** 2) 
    accel_x = acceleration * diff_x/(diff_x ** 2 + diff_y ** 2) 
    accel_y = acceleration * diff_y/(diff_x ** 2 + diff_y ** 2) 
    return accel_x, accel_y 

while True: 
    # update position based on velocity 
    planet.x += planet.vel_x * dt 
    planet.y += planet.vel_y * dt 

    # update velocity based on acceleration 
    accel_x, accel_y = calcGravity(sun, planet) 
    planet.vel_x += accel_x * dt 
    planet.vel_y += accel_y * dt 

Dies kann kreisförmige und elliptische Umlaufbahnen erzeugen. Das Erstellen eines umlaufenden Mondes erfordert einen sehr kleinen Zeitschritt (dt) für die numerische Integration.

Hinweis: Dieser Ansatz ist aufgrund der Grenzen der numerischen Integration geringfügig ungenau.

Beispiel-Implementierung in Pygame hier, darunter drei Planeten um eine Sonne, einen Mond und eine grundlegende Orbitalübertragung. https://github.com/c2huc2hu/orbital_mechanics