import pyxel
import math
import random

# Definition des couleurs
COLOR_BLACK = 0
COLOR_DARKBLUE = 1
COLOR_PURPLE = 2
COLOR_GREEN = 3
COLOR_BROWN = 4
COLOR_BLUE = 5
COLOR_LIGHTBLUE = 6
COLOR_WHITE = 7
COLOR_RED = 8
COLOR_ORANGE = 9
COLOR_YELLOW = 10
COLOR_LIGHTGREEN = 11
COLOR_CYAN = 12
COLOR_GREY = 13
COLOR_LIGHTROSE = 14
COLOR_ROSE = 15
PYXEL_WIDTH = 250
PYXEL_HEIGHT = 250
CENTER_X = PYXEL_WIDTH//2
CENTER_Y = PYXEL_HEIGHT//2

class Sun:
"""
Classe du soleil
"""
def __init__(self, name, x, y, information1, information2, radius):
self.name = name
self.x = x # Coordonnee x du centre du soleil
self.y = y # Coordonnee y du centre du soleil
self.radius = radius # radius du soleil
self.color = COLOR_ORANGE # Couleur de fond du soleil
self.second_color = COLOR_YELLOW # Couleur des dessins sur le soleil
self.sun_hovered = False
self.information1 = information1
self.information2 = information2


def check_hover_sun(self):
"""
Verifie si la souris survole le soleil
"""
mouse_x = pyxel.mouse_x # Position horizontale de la souris
mouse_y = pyxel.mouse_y # Position verticale de la souris
distance_to_mouse = (self.x - mouse_x) ** 2 + (self.y - mouse_y) ** 2 # Calcul de la distance au carre
self.sun_hovered = distance_to_mouse <= (self.radius + 1) ** 2 # Verification de la survol

def update(self):
"""
Met a jour l'etat du soleil a chaque frame
"""
self.check_hover_sun()

def draw(self):
"""
Dessin du soleil
"""
# Dessiner le fond du soleil
pyxel.circ(self.x, self.y, self.radius, self.color)
# Dessiner les details du soleil
pyxel.circb(self.x, self.y, self.radius, self.second_color) # Contour du soleil
pyxel.pset(self.x + self.radius // 2, self.y + self.radius // 2, self.second_color) # Point 1
pyxel.pset(self.x + self.radius // 2 - 1, self.y + self.radius // 2, self.second_color) # Point 2
pyxel.pset(self.x + self.radius // 2, self.y + self.radius // 2 - 1, self.second_color) # Point 3
pyxel.pset(self.x + self.radius // 2 + 1, self.y + self.radius // 2 - 1, self.second_color) # Point 4
pyxel.pset(self.x + self.radius // 2 - 1, self.y + self.radius // 2 + 1, self.second_color) # Point 5
pyxel.pset(self.x + self.radius // 2 - 2, self.y + self.radius // 2 + 1, self.second_color) # Point 6
pyxel.circ(self.x - 2, self.y, 2, self.second_color) # Dessin 1
pyxel.circ(self.x - 1, self.y - 1, 2, self.second_color) # Dessin 2
if self.sun_hovered: # Si la souris survole le soleil
pyxel.text(self.x - len(self.name) * 2, self.y - self.radius - 10, self.name, COLOR_GREEN) # Afficher le nom du soleil
pyxel.circb(self.x, self.y, self.radius + 2, COLOR_GREEN) # Dessiner un contour autour du soleil

class Asteroid:
"""
Classe des asteroides
"""
def __init__(self, x, y, radius, color, name, information1, information2):
self.x = x # Coordonnee x de l'asteroïde
self.y = y # Coordonnee y de l'asteroïde
self.radius = radius+1 # Rayon de l'asteroïde
self.color = color # Couleur de l'asteroïde
self.vx = random.uniform(-0.35, 0.35) # Vitesse horizontale initiale de l'asteroïde
self.vy = random.uniform(-0.35, 0.35) # Vitesse verticale initiale de l'asteroïde
self.name = name # Nom de l'asteroïde
self.information1 = information1 # informationrmation supplementaire 1 sur l'asteroïde
self.information2 = information2 # informationrmation supplementaire 2 sur l'asteroïde
self.asteroid_hovered = False # Indicateur si la souris survole l'asteroïde
self.exploding = False # Indicateur si l'asteroïde est en train d'exploser
self.explosion_frames = 0 # Nombre de frames ecoulees depuis le debut de l'explosion
self.explosion_duration = 30 # Duree totale de l'explosion en frames
self.disappearing = False # Indicateur si l'asteroïde est en train de disparaître
self.disappear_frames = 0 # Nombre de frames ecoulees depuis le debut de la disparition
self.disappear_duration = 20 # Duree totale de la disparition en frames
self.pieces = [] # Liste des pieces resultant de l'explosion de l'asteroïde
self.explosion_particles = [] # Liste des particules d'explosion

def check_hover_asteroid(self):
"""
Verifie si la souris survole l'asteroïde
"""
mouse_x = pyxel.mouse_x # Position horizontale de la souris
mouse_y = pyxel.mouse_y # Position verticale de la souris
distance_to_mouse = (self.x - mouse_x) ** 2 + (self.y - mouse_y) ** 2 # Calcul de la distance au carre
self.asteroid_hovered = distance_to_mouse <= (self.radius + 1) ** 2 # Verification de la survol

def start_explosion(self):
"""
Demarre l'animation d'explosion de l'asteroïde
"""
self.exploding = True # L'asteroïde commence a exploser
# Generer des pieces d'asteroïde
self.pieces = [] # Initialisation de la liste des morceaux
num_pieces = random.randint(2, 6) # Nombre aleatoire de morceaux
for _ in range(num_pieces):
piece_radius = random.uniform(self.radius * 0.2, self.radius * 0.5) # Taille proportionnelle des morceaux
angle = random.uniform(0, 2 * math.pi) # Angle de direction aleatoire
speed = random.uniform(1, 3) # Vitesse aleatoire des morceaux
self.pieces.append([self.x, self.y, piece_radius, self.color, math.cos(angle) * speed, math.sin(angle) * speed]) # Ajout des pieces a la liste
# Generer des petites particules d'explosion
for _ in range(100):
angle = random.uniform(0, 2 * math.pi) # Angle de direction aleatoire
speed = random.uniform(1.5, 3.5) # Vitesse aleatoire des particules
color = random.choice([self.color, COLOR_ORANGE, COLOR_YELLOW]) # Couleur aleatoire des particules
self.explosion_particles.append([self.x, self.y, color, math.cos(angle) * speed, math.sin(angle) * speed]) # Ajout des particules a la liste

def update(self):
"""
Met a jour les asteroïdes
"""
if self.exploding:
# Si l'asteroïde est en train d'exploser
self.explosion_frames += 1 # Incrementation du compteur de frames d'explosion
if self.explosion_frames >= self.explosion_duration:
# Si l'explosion est terminee
self.disappearing = True # Declenchement de la disparition de l'asteroïde
elif self.disappearing:
# Si l'asteroïde est en train de disparaître
self.disappear_frames += 1 # Incrementation du compteur de frames de disparition
if self.disappear_frames >= self.disappear_duration:
# Si la disparition est terminee
self.x = 1000 # Deplacement de l'asteroïde hors de l'ecran (cache)
self.y = 1000 # Deplacement de l'asteroïde hors de l'ecran (cache)
else:
# Si l'asteroïde est en mouvement normal
self.x += self.vx # Mise a jour de la position horizontale de l'asteroïde
self.y += self.vy # Mise a jour de la position verticale de l'asteroïde
self.check_hover_asteroid() # Verification si la souris survole l'asteroïde

def draw(self):
"""
Dessine les asteroïde (et leurs explosions)
"""
if self.exploding:
# Si l'asteroïde est en train d'exploser
# Dessiner les pieces d'asteroïdes
for piece in self.pieces:
pyxel.circ(piece[0], piece[1], piece[2], piece[3]) # Dessiner un morceau d'asteroïde
piece[0] += piece[4] # Mise a jour de la position horizontale du morceau
piece[1] += piece[5] # Mise a jour de la position verticale du morceau
# Dessiner les petites particules d'explosion
for particle in self.explosion_particles:
pyxel.pset(particle[0], particle[1], particle[2]) # Dessiner une particule d'explosion
particle[0] += particle[3] # Mise a jour de la position horizontale de la particule
particle[1] += particle[4] # Mise a jour de la position verticale de la particule
else:
# Si l'asteroïde n'est pas en train d'exploser
pyxel.circ(self.x, self.y, self.radius, self.color) # Dessiner l'asteroïde
if self.asteroid_hovered:
# Si la souris survole l'asteroïde
pyxel.text(self.x - len(self.name) * 2, self.y - self.radius - 10, self.name, COLOR_GREEN) # Afficher le name de l'asteroïde
pyxel.circb(self.x, self.y, self.radius + 2, COLOR_GREEN) # Dessiner un contour autour de l'asteroïde

class Planet:
"""
Classe des planètes
"""
def __init__(self, name, radius, distance, color, information1, information2, game, orbital_period, moons, sun_position, ring_size, ring_color):
# Initialisation des attributs de la planete
self.name = name # Nom de la planete
self.radius = radius # Rayon de la planete
self.distance = distance // 1.75 # Distance orbitale par rapport au soleil (divisee pour le rendu)
self.color = color # Couleur de la planete
self.information1 = information1 # Information supplementaire 1 sur la planete
self.information2 = information2 # Information supplementaire 2 sur la planete
self.game = game # Instance du jeu auquel la planete appartient
self.orbital_period = orbital_period # Periode orbitale de la planete
self.moons = moons # Nombre de lunes de la planete
self.sun_position = sun_position # Position du soleil dans le jeu
self.speed = 2 * math.pi / self.orbital_period # Vitesse orbitale de la planete (en radians par frame)
self.angle = 0 # Angle actuel de la planete sur son orbite
self.trace = [] # Liste des positions precedentes de la planete pour dessiner son orbite
self.planet_hovered = False # Indicateur si la souris survole la planete
self.ring_size = ring_size # Taille des anneaux de la planete (0: pas, 1: petit, 2: grand)
self.ring_color = ring_color # Couleur des anneaux de la planete

def check_hover_planet(self):
"""
Vérifie si la souris survole la planète
"""
# Verifie si la souris survole la planete
mouse_x = pyxel.mouse_x # Position horizontale de la souris
mouse_y = pyxel.mouse_y # Position verticale de la souris
distance_to_mouse = (self.x - mouse_x) ** 2 + (self.y - mouse_y) ** 2 # Calcul de la distance au carre
self.planet_hovered = distance_to_mouse <= (self.radius + 1) ** 2 # Verification de la survol

def update(self):
"""
Met à jours les planètes
"""
# Met a jour la position et l'etat de la planete a chaque frame
self.angle += self.speed # Mise a jour de l'angle orbital de la planete
self.x = self.sun_position[0] + self.distance * math.cos(self.angle) # Calcul de la position horizontale par rapport au soleil
self.y = self.sun_position[1] + self.distance * math.sin(self.angle) # Calcul de la position verticale par rapport au soleil
self.trace.append((self.x, self.y)) # Ajout de la position actuelle a la liste des positions precedentes
self.check_hover_planet() # Verification si la souris survole la planete

def draw(self):
"""
Dessine les planètes et leurs déplacements
"""
# Dessine la planete et ses elements associes
# Dessin des orbites
for i in range(1, len(self.trace)):
pyxel.line(self.trace[i-1][0], self.trace[i-1][1], self.trace[i][0], self.trace[i][1], 7) # Dessin de chaque segment de l'orbite
# Dessin de la planete
pyxel.circ(self.x, self.y, self.radius, self.color) # Dessin du corps de la planete
# Dessin des anneau de la planete
if self.ring_size == 1:
pyxel.line(self.x-self.radius, self.y-self.radius, self.x+self.radius, self.y+self.radius, self.ring_color) # Dessin d'anneaux de size petite
elif self.ring_size == 2:
pyxel.line(self.x-self.radius-1, self.y-self.radius-1, self.x+self.radius+1, self.y+self.radius+1, self.ring_color) # Dessin d'anneaux de size grande
# Affichage du name de la planete au survol
if self.planet_hovered:
pyxel.text(self.x - len(self.name) * 2, self.y - self.radius - 10, self.name, COLOR_GREEN) # Affichage du nom
pyxel.circb(self.x, self.y, self.radius+2, COLOR_GREEN) # Dessin d'un contour autour de la planete

class SolarSystem:
"""
Classe du système solaire (regroupant toutes les autres fonctions)
"""
def __init__(self):
# Initialisation du systeme solaire avec le sun, la position du sun, les planetes et les asteroïdes
self.sun_position = (125, 125) # Position initiale du soleil
self.sun = [Sun("Soleil", self.sun_position[0], self.sun_position[1], "Il possède 214 lunes", "Vieux de 4,603 milliards d'années", 8)] # Creation de l'objet soleil
self.planets = [
Planet("Mercure", 2, 30, COLOR_GREY, "Mercure est la premiere planete du systeme solaire.", "La plus petite planete du systeme solaire.", "game1", 88, 0, self.sun_position, 0, 0),
Planet("Venus", 3, 45, COLOR_YELLOW, "Venus est la deuxieme planete a partir du Soleil.", "Elle est nommee d'apres la deesse romaine de l'amour et de la beaute.", "game2", 225, 0, self.sun_position, 0, 0),
Planet("Terre", 4, 60, COLOR_BLUE, "La Terre est la troisieme planete a partir du Soleil.", "Le seul objet astronameique connu a abriter la vie.", "game3", 365, 1, self.sun_position, 0, 0),
Planet("Mars", 3, 80, COLOR_RED, "Mars est la quatrieme planete a partir du Soleil.", "La deuxieme plus petite planete du systeme solaire.", "game4", 687, 2, self.sun_position, 0, 0),
Planet("Jupiter", 7, 110, COLOR_LIGHTROSE, "Jupiter est la cinquieme planete a partir du Soleil.", "La plus grande planete du systeme solaire.", "game5", 4333, 79, self.sun_position, 0, 0),
Planet("Saturne", 6, 140, COLOR_ROSE, "Saturne est la sixieme planete a partir du Soleil.", "La deuxieme plus grande du systeme solaire.", "game6", 10759, 82, self.sun_position, 2, COLOR_GREY),
Planet("Uranus", 5, 170, COLOR_CYAN, "Uranus est la septieme planete a partir du Soleil.", "C'est l'atmosphere planetaire la plus froide du systeme solaire (−224°C).", "game7", 30688, 27, self.sun_position, 1, COLOR_GREY),
Planet("Neptune", 4, 200, COLOR_LIGHTBLUE, "Neptune est la huitieme et la plus eloignee planete du Soleil.", "Elle est nommee d'apres le dieu romain de la mer.", "game8", 60182, 14, self.sun_position, 0, 0)
] # Liste des planetes du systeme solaire avec leurs caracteristiques
self.asteroids_data = [
{"name": "Ceres", "size": 940, "information1": "Asteroïde decouvert le : 1er janvier 1801", "information2": "Le plus grand asteroïde de la liste."},
{"name": "Pallas", "size": 544, "information1": "Asteroïde decouvert le : 28 mars 1802", "information2": "Le deuxieme plus grand asteroïde de la liste."},
{"name": "Vesta", "size": 525, "information1": "Asteroïde decouvert le : 29 mars 1807", "information2": "Le troisieme plus grand asteroïde de la liste."},
{"name": "Hygie", "size": 430, "information1": "Asteroïde decouvert le : 12 avril 1849", "information2": "Le quatrieme plus grand asteroïde de la liste."},
{"name": "Interamnia", "size": 350, "information1": "Asteroïde decouvert le : 2 octobre 1910", "information2": "Le cinquieme plus grand asteroïde de la liste."},
{"name": "Eunameia", "size": 268, "information1": "Asteroïde decouvert le : 29 juillet 1851", "information2": "Le sixieme plus grand asteroïde de la liste."},
{"name": "Sylvia", "size": 267, "information1": "Asteroïde decouvert le : 16 mai 1866", "information2": "Le septieme plus grand asteroïde de la liste."},
{"name": "Euphrosyne", "size": 260, "information1": "Asteroïde decouvert le : 1er septembre 1854", "information2": "Le huitieme plus grand asteroïde de la liste."},
{"name": "Davida", "size": 327, "information1": "Asteroïde decouvert le : 19 mai 1903", "information2": "Le neuvieme plus grand asteroïde de la liste."},
{"name": "Europe", "size": 315, "information1": "Asteroïde decouvert le : 4 fevrier 1857", "information2": "Le dixieme plus grand asteroïde de la liste."},
{"name": "Psyche", "size": 226, "information1": "Asteroïde decouvert le : 17 mars 1852", "information2": "Le onzieme plus grand asteroïde de la liste."},
{"name": "Herculine", "size": 225, "information1": "Asteroïde decouvert le : 20 avril 1880", "information2": "Le douzieme plus grand asteroïde de la liste."},
{"name": "Hestia", "size": 215, "information1": "Asteroïde decouvert le : 16 août 1880", "information2": "Le treizieme plus grand asteroïde de la liste."},
{"name": "Cybele", "size": 239, "information1": "Asteroïde decouvert le : 8 mars 1861", "information2": "Le quatorzieme plus grand asteroïde de la liste."},
{"name": "Themis", "size": 200, "information1": "Asteroïde decouvert le : 5 avril 1853", "information2": "Le quinzieme plus grand asteroïde de la liste."},
{"name": "Juno", "size": 233, "information1": "Asteroïde decouvert le : 1er septembre 1804", "information2": "Le seizieme plus grand asteroïde de la liste."},
{"name": "Hebe", "size": 186, "information1": "Asteroïde decouvert le : 1er juillet 1847", "information2": "Le dix-septieme plus grand asteroïde de la liste."},
{"name": "Doris", "size": 189, "information1": "Asteroïde decouvert le : 19 mai 1872", "information2": "Le dix-huitieme plus grand asteroïde de la liste."},
{"name": "Siwa", "size": 105, "information1": "Asteroïde decouvert le : 19 fevrier 1857", "information2": "Le dix-neuvieme plus grand asteroïde de la liste."},
{"name": "Iris", "size": 200, "information1": "Asteroïde decouvert le : 13 août 1847", "information2": "Le vingtieme plus grand asteroïde de la liste."},
{"name": "Florence", "size": 130, "information1": "Asteroïde decouvert le : 18 octobre 1847", "information2": "Le vingt et unieme plus grand asteroïde de la liste."},
{"name": "Metis", "size": 200, "information1": "Asteroïde decouvert le : 25 avril 1848", "information2": "Le vingt-deuxieme plus grand asteroïde de la liste."},
{"name": "Hera", "size": 210, "information1": "Asteroïde decouvert le : 7 septembre 1868", "information2": "Le vingt-troisieme plus grand asteroïde de la liste."},
{"name": "Victoria", "size": 112, "information1": "Asteroïde decouvert le : 13 septembre 1861", "information2": "Le vingt-quatrieme plus grand asteroïde de la liste."},
{"name": "Lutece", "size": 100, "information1": "Asteroïde decouvert le : 15 novembre 1852", "information2": "Le vingt-cinquieme plus grand asteroïde de la liste."},
{"name": "Ida", "size": 52, "information1": "Asteroïde decouvert le : 29 septembre 1884", "information2": "Le vingt-sixieme plus grand asteroïde de la liste."},
{"name": "Mathilde", "size": 52, "information1": "Asteroïde decouvert le : 17 novembre 1885", "information2": "Le vingt-septieme plus grand asteroïde de la liste."},
{"name": "Antiope", "size": 84, "information1": "Asteroïde decouvert le : 1er octobre 1866", "information2": "Le vingt-huitieme plus grand asteroïde de la liste."},
{"name": "Eugenie", "size": 214, "information1": "Asteroïde decouvert le : 27 juin 1857", "information2": "Le vingt-neuvieme plus grand asteroïde de la liste."},
{"name": "Hector", "size": 370, "information1": "Asteroïde decouvert le : 10 fevrier 1907", "information2": "Le trentieme plus grand asteroïde de la liste."},
{"name": "Cleopâtre", "size": 135, "information1": "Asteroïde decouvert le : 10 avril 1880", "information2": "Le trente et unieme plus grand asteroïde de la liste."},
{"name": "Antiope", "size": 84, "information1": "Asteroïde decouvert le : 1er octobre 1866", "information2": "Le trente-deuxieme plus grand asteroïde de la liste."},
{"name": "Éros", "size": 34.4, "information1": "Asteroïde decouvert le : 13 août 1898", "information2": "Le trente-troisieme plus grand asteroïde de la liste."},
{"name": "Gaspra", "size": 18, "information1": "Asteroïde decouvert le : 30 juillet 1991", "information2": "Le trente-quatrieme plus grand asteroïde de la liste."},
{"name": "Mathilde", "size": 52, "information1": "Asteroïde decouvert le : 17 novembre 1885", "information2": "Le trente-cinquieme plus grand asteroïde de la liste."},
{"name": "Gryphon", "size": 6, "information1": "Asteroïde decouvert le : 19 avril 1848", "information2": "Le trente-sixieme plus grand asteroïde de la liste."},
{"name": "Alinda", "size": 7, "information1": "Asteroïde decouvert le : 27 fevrier 1919", "information2": "Le trente-septieme plus grand asteroïde de la liste."}
] # Donnees sur les asteroïdes avec leurs noms, sizes et informations
self.asteroids = []
self.max_asteroids = 5
while len(self.asteroids) < self.max_asteroids:
self.create_asteroids() # Creation des asteroïdes
self.selected_planet = None # Planete selectionnee (initialisation a None)
self.year = 0 # Compteur d'annees initialise a zero
self.day = 0 # Compteur d'annees initialise a zero

def create_asteroids(self):
"""
Cree de nouveaux asteroïdes
"""
asteroid_data = random.choice(self.asteroids_data) # Selectionne aleatoirement les donnees d'un asteroïde
x = random.randint(0, pyxel.width) # Coordonnee x aleatoire
y = random.randint(0, pyxel.height) # Coordonnee y aleatoire
size = asteroid_data["size"] // 125 # Taille de l'asteroïde (normalisee)
color = random.choice([COLOR_GREY, COLOR_BROWN]) # Couleur de l'asteroïde
new_asteroid = Asteroid(x, y, size, color, asteroid_data["name"], asteroid_data["information1"], asteroid_data["information2"]) # Cree un nouvel objet Asteroïde
self.asteroids.append(new_asteroid) # Ajoute l'asteroïde a la liste des asteroïdes

def update(self):
"""
Met a jour le système solaire
"""
for planet in self.planets:
planet.update()
for asteroid in range(len(self.asteroids)):
self.asteroids[asteroid].update()
# Supprime les asteroïdes qui sortent de l'ecran
if self.asteroids[asteroid].x < 0 or self.asteroids[asteroid].x > pyxel.width or self.asteroids[asteroid].y > pyxel.height or self.asteroids[asteroid].y < 0:
del(self.asteroids[asteroid])
# Genere de nouveaux asteroïdes s'il y en a moins que le maximum autorise
while len(self.asteroids) < self.max_asteroids:
self.create_asteroids()
for sun in self.sun:
sun.update()
# Incremente les compteurs
self.year += 1/365
self.day += 1

def draw(self):
"""
Dessine le système solaire
"""
# Efface l'ecran
pyxel.cls(0)
# Dessine des etoiles aleatoires
for _ in range((pyxel.width+pyxel.height)//10):
x = random.randint(0, pyxel.width)
y = random.randint(0, pyxel.height)
pyxel.pset(x, y, COLOR_WHITE)
# Dessine les asteroïdes
for asteroid in self.asteroids:
asteroid.draw()
# Dessine le soleil
for sun in self.sun:
sun.draw()
# Dessine les planetes
for planet in self.planets:
planet.draw()
# Affiche les compteurs
pyxel.text(5, 5, "JOURS : " + str(int(self.day)), COLOR_WHITE)
pyxel.text(5, 15, "ANNEES : " + str(int(self.year)), COLOR_WHITE)

class End:
"""
Classe de la fin de l'univers (soleil qui explose)
"""
def __init__(self):
self.explosion_size = 0
self.explosion_size_max = pyxel.width*1.5
self.explosion_particles = []
self.end_starting = False

def update(self):
"""
Met à jour l'explosion du soleil
"""
# L'explosion est lancée
self.end_starting = True
# Tant que le cercle d'explosion ne fait pas sa taille maximale
if self.explosion_size <= self.explosion_size_max:
self.explosion_size += 1
self.explosion_random_x = random.randint(0, pyxel.height)
self.explosion_random_y = random.randint(0, pyxel.width)
# Generer des petites particules d'explosion
for _ in range(250):
angle = random.uniform(0, 2 * math.pi) # Angle de direction aleatoire
speed = random.uniform(1.5, 3.5) # Vitesse aleatoire des particules
color = random.choice([COLOR_RED, COLOR_ORANGE, COLOR_YELLOW]) # Couleur aleatoire des particules
self.explosion_particles.append([CENTER_X, CENTER_Y, color, math.cos(angle) * speed, math.sin(angle) * speed]) # Ajout des particules a la liste

def draw(self):
"""
Dessine l'explosion du soleil
"""
# Efface l'écran
pyxel.cls(0)
# Explosion
if self.explosion_size <= self.explosion_size_max:
# Dessine l'explosion du soleil
for i in range(0, 10):
# Rayon d'explosion
pyxel.circb(CENTER_X, CENTER_Y, self.explosion_size+i, random.choice([COLOR_RED, COLOR_ORANGE, COLOR_YELLOW, COLOR_GREY]))
# Explosion pour simuler des "fausses collisions"
pyxel.circb(self.explosion_random_x, self.explosion_random_y, i, random.choice([COLOR_RED, COLOR_ORANGE, COLOR_YELLOW, COLOR_GREY]))
# Dessiner les petites particules d'explosion
for particle in self.explosion_particles:
pyxel.pset(particle[0], particle[1], particle[2]) # Dessiner une particule d'explosion
particle[0] += particle[3] # Mise a jour de la position horizontale de la particule
particle[1] += particle[4] # Mise a jour de la position verticale de la particule
# Efface tout ce qui a déjà explosé
pyxel.circ(CENTER_X, CENTER_Y, self.explosion_size, COLOR_PURPLE)
# Dessiner le cercle lumineux
radius = self.explosion_size // 10
pyxel.circ(CENTER_X, CENTER_Y, radius, COLOR_WHITE)
# Calculer le nombre de points en fonction du rayon du cercle
num_points = int(2 * math.pi * radius)
# Calculer l'écart entre le cercle et les points
gap_size = radius * 0.2
# Dessiner les points autour du cercle avec un espacement variable
for i in range(num_points):
angle = (i / num_points) * 2 * math.pi
# Ajouter un écart entre le cercle et certains points
if random.random() < 0.5: # ajustez ce seuil selon la proportion de points avec écart désirée
point_x = CENTER_X + (radius + gap_size) * math.cos(angle)
point_y = CENTER_Y + (radius + gap_size) * math.sin(angle)
else:
point_x = CENTER_X + radius * math.cos(angle)
point_y = CENTER_Y + radius * math.sin(angle)
pyxel.pset(int(point_x), int(point_y), COLOR_WHITE)
# Ecran final
else:
# Affiche les crédits
pyxel.text(5, 100, "C'est la fin, vous venez d'assister a l'explosion du soleil", COLOR_WHITE)
pyxel.text(55, 110, "Par les créateurs de", COLOR_WHITE)
pyxel.text(133, 110, "QUOICOUNEIGHBOR 1", random.randint(0, 15))
pyxel.text(90, 120, "Merci d'avoir joue !", COLOR_WHITE)

class App:
"""
Classe du lancement du programme
"""
def __init__(self):
# Initialisation de l'application Pyxel avec une taille de fenêtre de 250x250 pixels et un taux de rafraîchissement de 60 FPS
pyxel.init(PYXEL_WIDTH, PYXEL_HEIGHT, fps=60)
# Initialisation du systeme solaire
self.solar_system = SolarSystem()
self.end = End()
# Initialisation de l'objet selectionne a None
self.selected_object = None
# Definition des coordonnees et dimensions des boutons de retour et d'action
self.return_button_x = 40
self.return_button_y = 220
self.return_button_width = 60
self.return_button_height = 15
self.action_button_x = 150
self.action_button_y = 220
self.action_button_width = 60
self.action_button_height = 15
# Activation de la souris
pyxel.mouse(True)
# Lancement de la boucle principale de Pyxel avec la fonction update et draw de cette classe
pyxel.run(self.update, self.draw)

def update(self):
"""
Met à jour les interactions utilisateur et le jeu en fonction de celles-ci
"""
# Gestion des clics de souris
if pyxel.btnp(pyxel.MOUSE_BUTTON_LEFT) and self.solar_system.year < 100:
# Vérification des clics sur les boutons de retour et d'action
if self.selected_object:
# Si l'univers est encore "existant"
mouse_x = pyxel.mouse_x
mouse_y = pyxel.mouse_y
# Clic sur le bouton de retour
if (self.return_button_x <= mouse_x <= self.return_button_x + self.return_button_width and self.return_button_y <= mouse_y <= self.return_button_y + self.return_button_height):
self.selected_object = None
# Clic sur le bouton d'action
if (self.action_button_x <= mouse_x <= self.action_button_x + self.action_button_width and self.action_button_y <= mouse_y <= self.action_button_y + self.action_button_height): # Vérification du type d'objet sélectionné
if isinstance(self.selected_object, Asteroid):
# Déclenchement de l'explosion de l'astéroïde
self.selected_object.start_explosion()
# Désélection de l'objet une fois qu'il a explosé
self.selected_object = None
elif isinstance(self.selected_object, Planet):
# Lance le sélectionneur de jeu (hors simulation nsi)
self.selected_object = None
pass # Suite hors simulation nsi
elif isinstance(self.selected_object, Sun):
# Démarre le grand déchirement
self.selected_object = None
self.solar_system.year = 100
else:
# Vérification des survols des planètes, soleil et des astéroïdes
for sun in self.solar_system.sun:
if sun.sun_hovered:
self.selected_object = sun
break
for movingplanet in self.solar_system.planets:
if movingplanet.planet_hovered:
self.selected_object = movingplanet
break
for asteroid in self.solar_system.asteroids:
if asteroid.asteroid_hovered:
# Vérifie si l'astéroïde a déjà explosé
if not asteroid.exploding:
self.selected_object = asteroid
break

# Mise à jour du système solaire uniquement si aucun objet n'est sélectionné ou si l'objet sélectionné est un astéroïde et qu'il n'explose pas
if not self.selected_object or (isinstance(self.selected_object, Asteroid) and not self.selected_object.exploding):
if self.solar_system.year >= 100: # Dessine la fin de l'univers et les crédits si le jeu est fini
self.end.update()
else: # Dessin du système solaire
self.solar_system.update()

def draw(self):
"""
Dessine chaque fonction possible en fonction des choix de l'utilisateur
"""
# Efface l'ecran
pyxel.cls(0)
# Dessine l'interface de l'objet selectionne ou le systeme solaire complet
if self.selected_object:
# Dessin des boutons de retour et d'action
pyxel.rectb(self.return_button_x, self.return_button_y, self.return_button_width, self.return_button_height, COLOR_WHITE)
pyxel.text(self.return_button_x + 5, self.return_button_y + 5, "Retour", COLOR_WHITE)
pyxel.rectb(self.action_button_x, self.action_button_y, self.action_button_width, self.action_button_height, COLOR_WHITE)
# Affichage de l'objet en grand
obj_radius = self.selected_object.radius * 6.5
# Dessin d'un cercle pour representer l'objet selectionne
pyxel.circ(125, 100, obj_radius, self.selected_object.color)
# Affichage du name de l'objet
text_width = len(self.selected_object.name) * pyxel.FONT_WIDTH
pyxel.text(125 - text_width // 2, 10, self.selected_object.name, COLOR_WHITE)
# Affichage des informationrmations sur l'objet
pyxel.text(5, 165, self.selected_object.information1, COLOR_WHITE)
pyxel.text(5, 175, self.selected_object.information2, COLOR_WHITE)
# Dessin de l'écran de la planète
if isinstance(self.selected_object, Planet):
pyxel.text(self.action_button_x + 5, self.action_button_y + 5, "Jouer", COLOR_WHITE)
# Affichage des anneaux
if self.selected_object.ring_size >= 1:
ring_radius = obj_radius + self.selected_object.ring_size * 6
ring_x = 125
ring_y = 100
for i in range(-6*self.selected_object.ring_size, 6*self.selected_object.ring_size):
pyxel.line(ring_x - ring_radius + i, ring_y - ring_radius, ring_x + ring_radius + i, ring_y + ring_radius, self.selected_object.ring_color)
# Affichage de la periode orbitale et du nombre de lunes pour les planetes
pyxel.text(5, 185, "Jours par orbite : " + str(self.selected_object.orbital_period), COLOR_WHITE)
pyxel.text(5, 195, "Nombre de lunes : " + str(self.selected_object.moons), COLOR_WHITE)
# Dessin de l'écran de l'astéroide
elif isinstance(self.selected_object, Asteroid):
pyxel.text(self.action_button_x + 5, self.action_button_y + 5, "Exploser", COLOR_WHITE)
# Dessin de l'écran du soleil
elif isinstance(self.selected_object, Sun):
pyxel.text(self.action_button_x + 5, self.action_button_y + 5, "End.", COLOR_WHITE)
else:
if self.solar_system.year >= 100: # Dessine la fin de l'univers et les crédits si le jeu est fini
self.end.draw()
else: # Dessin du système solaire
self.solar_system.draw()

# Lancement de l'application
App()