Python Funções de calculo para Orbita de Planetas programação em Python

Cairo Alberto · 1 de junho de 2023

estou tentando programar um simulador de orbita do sistema solar, consegui fazer funcionar com alguns planetas mas estão apenas circulando o sol, alguém qual pe a função geometrica de calculos que gera a elipse, e quais as variaveis para cada planeta? e como implementar elas em python?
tem alguns problemas mas agra estou tentando fazer funcionar a orbita:

imagens: https://drive.google.com/file/d/12Y1O2tkfX2N8mDRMyF-LUG_3hE_cY6WR/view?usp=drive_link

quero melhorar essa parte:

def calculate_planet_position(center, radius, angle):
    x = center[0] + radius * math.cos(angle)
    y = center[1] + radius * math.sin(angle)
    return int(x), int(y)

Codigo completo:

import pygame
import math

# Inicialização do Pygame
pygame.init()

# Lista de resoluções suportadas
resolutions = [
    (800, 600),
    (1024, 768),
    (1280, 720),
    (1920, 1080),
    (1920, 1080),
    (2560, 1440),
    (3840, 2160)
]

# Função para exibir o menu de seleção de resolução dentro da janela
def display_resolution_menu(screen):
    font = pygame.font.Font(None, 30)
    text1 = font.render("Selecione a resolução desejada:", True, (255, 255, 255))
    screen.blit(text1, (20, 20))

    for i, res in enumerate(resolutions):
        text = font.render(f"{i+1}. {res[0]}x{res[1]}", True, (255, 255, 255))
        screen.blit(text, (20, 60 + i * 30))
    pygame.display.flip()

    selected = False
    while not selected:
        for event in pygame.event.get():
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_1:
                    resolution = resolutions[0]
                    selected = True
                elif event.key == pygame.K_2:
                    resolution = resolutions[1]
                    selected = True
                elif event.key == pygame.K_3:
                    resolution = resolutions[2]
                    selected = True
                elif event.key == pygame.K_4:
                    resolution = resolutions[3]
                    selected = True
                elif event.key == pygame.K_5:
                    resolution = resolutions[4]
                    selected = True
                elif event.key == pygame.K_6:
                    resolution = resolutions[5]
                    selected = True
                elif event.key == pygame.K_7:
                    resolution = resolutions[6]
                    selected = True

        if selected:  # Verificar se a resolução foi selecionada antes de atualizar a tela
            screen.fill((0, 0, 0))  # Limpar a tela
            pygame.display.flip()  # Atualizar a tela

    return resolution

# Função para exibir o menu de seleção do modo de exibição dentro da janela
def display_display_mode_menu(screen):
    font = pygame.font.Font(None, 30)
    text1 = font.render("Selecione o modo de exibição desejado:", True, (255, 255, 255))
    screen.blit(text1, (20, 20))
    text2 = font.render("1. Fullscreen", True, (255, 255, 255))
    screen.blit(text2, (20, 60))
    #text3 = font.render("2. Borderless", True, (255, 255, 255))
    #screen.blit(text3, (20, 90))
    text4 = font.render("3. Window", True, (255, 255, 255))
    screen.blit(text4, (20, 120))
    pygame.display.flip()

    selected = False
    while not selected:
        for event in pygame.event.get():
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_1:
                    display_mode = pygame.FULLSCREEN
                    selected = True
                elif event.key == pygame.K_2:
                    display_mode = pygame.NOFRAME
                    selected = True
                elif event.key == pygame.K_3:
                    display_mode = 0
                    selected = True

        if selected:  # Verificar se o modo de exibição foi selecionado antes de atualizar a tela
            screen.fill((0, 0, 0))  # Limpar a tela
            pygame.display.flip()  # Atualizar a tela

    return display_mode

# Função para calcular a posição de um planeta na órbita
def calculate_planet_position(center, radius, angle):
    x = center[0] + radius * math.cos(angle)
    y = center[1] + radius * math.sin(angle)
    return int(x), int(y)

# Função para redimensionar as imagens dos planetas
def resize_planet_images():
    sun_image = pygame.image.load("sun.png")
    sun_image = pygame.transform.scale(sun_image, (100, 100))  # Redimensionando para 100x100 pixels

    mercury_image = pygame.image.load("mercury.png")
    mercury_image = pygame.transform.scale(mercury_image, (40, 40))  # Redimensionando para 40x40 pixels

    venus_image = pygame.image.load("venus.png")
    venus_image = pygame.transform.scale(venus_image, (60, 60))  # Redimensionando para 60x60 pixels

    earth_image = pygame.image.load("earth.png")
    earth_image = pygame.transform.scale(earth_image, (60, 60))  # Redimensionando para 60x60 pixels

    mars_image = pygame.image.load("mars.png")
    mars_image = pygame.transform.scale(mars_image, (50, 50))  # Redimensionando para 50x50 pixels

    moon_image = pygame.image.load("moon.png")
    moon_image = pygame.transform.scale(moon_image, (20, 20))  # Redimensionando para 20x20 pixels

    return sun_image, mercury_image, venus_image, earth_image, mars_image, moon_image

# Definição das dimensões da tela
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Órbita dos Planetas")

# Redimensionamento das imagens dos planetas
sun_image, mercury_image, venus_image, earth_image, mars_image, moon_image = resize_planet_images()

# Carregamento da imagem de fundo
background_image = pygame.image.load("space.jpg")
background_image = pygame.transform.scale(background_image, (WIDTH, HEIGHT))

# Posições iniciais dos planetas
sun_pos = (WIDTH // 2, HEIGHT // 2)
mercury_radius = 100
venus_radius = 200
earth_radius = 300
mars_radius = 400
moon_radius = 40

# Ângulos iniciais para os planetas
mercury_angle = 0
venus_angle = 0
earth_angle = 0
mars_angle = 0
moon_angle = 0

# Velocidades de rotação dos planetas
mercury_rotation_speed = 1/1000  # Velocidade de rotação de Mercúrio
venus_rotation_speed = 0.8/1000  # Velocidade de rotação de Vênus
earth_rotation_speed = 0.6/1000  # Velocidade de rotação da Terra
mars_rotation_speed = 0.4/1000  # Velocidade de rotação de Marte
moon_rotation_speed = 0.4/1000  # Velocidade de rotação da lua

# Loop principal do jogo
running = True
resolution_selected = False
display_mode_selected = False
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    if not resolution_selected:
        resolution = display_resolution_menu(screen)
        WIDTH, HEIGHT = resolution
        screen = pygame.display.set_mode((WIDTH, HEIGHT))
        pygame.display.set_caption("Órbita dos Planetas")
        background_image = pygame.transform.scale(background_image, (WIDTH, HEIGHT))
        resolution_selected = True

    if resolution_selected and not display_mode_selected:
        display_mode = display_display_mode_menu(screen)
        pygame.display.set_mode((WIDTH, HEIGHT), display_mode)
        display_mode_selected = True

    screen.blit(background_image, (0, 0))  # Desenhar o fundo na tela

    # Calcular as posições dos planetas na órbita
    mercury_pos = calculate_planet_position(sun_pos, mercury_radius, mercury_angle)
    venus_pos = calculate_planet_position(sun_pos, venus_radius, venus_angle)
    earth_pos = calculate_planet_position(sun_pos, earth_radius, earth_angle)
    mars_pos = calculate_planet_position(sun_pos, mars_radius, mars_angle)
    moon_pos = calculate_planet_position(earth_pos, moon_radius, moon_angle)

    # Desenhar os planetas na tela
    screen.blit(sun_image, (sun_pos[0] - sun_image.get_width() // 2, sun_pos[1] - sun_image.get_height() // 2))
    screen.blit(mercury_image, (mercury_pos[0] - mercury_image.get_width() // 2, mercury_pos[1] - mercury_image.get_height() // 2))
    screen.blit(venus_image, (venus_pos[0] - venus_image.get_width() // 2, venus_pos[1] - venus_image.get_height() // 2))
    screen.blit(earth_image, (earth_pos[0] - earth_image.get_width() // 2, earth_pos[1] - earth_image.get_height() // 2))
    screen.blit(mars_image, (mars_pos[0] - mars_image.get_width() // 2, mars_pos[1] - mars_image.get_height() // 2))
    screen.blit(moon_image, (moon_pos[0] - moon_image.get_width() // 2, moon_pos[1] - moon_image.get_height() // 2))

    # Atualizar os ângulos dos planetas para simular a rotação
    mercury_angle += mercury_rotation_speed
    venus_angle += venus_rotation_speed
    earth_angle += earth_rotation_speed
    mars_angle += mars_rotation_speed
    moon_angle += moon_rotation_speed

    pygame.display.flip()  # Atualizar a tela

# Encerramento do Pygame
pygame.quit()

Swalls · 1 de junho de 2023

procure sobre as bibliotecas astropy, skyfield, polipy e pyephem

Flávio Pedroza · 1 de junho de 2023

você tem que modificar essa função e acrescentar mais um raio como parâmetro

def calculate_planet_position(center, radius, angle):
    x = center[0] + radius * math.cos(angle)
    y = center[1] + radius * math.sin(angle)
    return int(x), int(y)

ficaria assim (eu acho, não sei python)

def calculate_planet_position(center, radiush, radiusv, angle):
    x = center[0] + radiush * math.cos(angle)
    y = center[1] + radiusv * math.sin(angle)
    return int(x), int(y)

radiush é a largura da elipse, dividida por 2 e radiusv a altura dividida por 2