import pyxel import math import random # Definition des variables globales 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 return_button_x = 40 return_button_y = 220 action_return_width = 60 action_return_height = 15 action_button_x = 150 action_button_y = 220 action_button_width = 60 action_button_height = 15 ######################################################## ### SYSTEME SOLAIRE ### ######################################################## 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 """ distance_to_mouse = (self.x - pyxel.mouse_x) ** 2 + (self.y - pyxel.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.5, 0.5) # Vitesse horizontale initiale de l'asteroïde self.vy = random.uniform(-0.5, 0.5) # 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_over = False # Indicateur que l'astéroide a finit d'exploser self.explosion_frames = 0 # Nombre de frames ecoulees depuis le debut de l'explosion self.explosion_duration = 60 # Duree totale de l'explosion en frames self.pieces = [] # Liste des pieces resultant de l'explosion de l'asteroïde self.particles = [] # Liste des particules d'explosion def check_hover_asteroid(self): """ Verifie si la souris survole l'asteroïde """ distance_to_mouse = (self.x - pyxel.mouse_x) ** 2 + (self.y - pyxel.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.25, 2.5) # Vitesse aleatoire des morceaux life = random.randint(20, 40) # Durée de vie aléatoire self.pieces.append([self.x, self.y, piece_radius, self.color, math.cos(angle) * speed, math.sin(angle) * speed, life]) # Ajout des morceaux 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.75, 3.5) # Vitesse aleatoire des particules life = random.randint(20, 40) # Durée de vie aléatoire color = random.choice([self.color, COLOR_ORANGE, COLOR_YELLOW]) # Couleur aleatoire des particules self.particles.append([self.x, self.y, color, math.cos(angle) * speed, math.sin(angle) * speed, life]) # 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 for i in range(len(self.particles)): self.particles[i][5] -= 1 for i in range(len(self.pieces)): self.pieces[i][6] -= 1 if self.explosion_frames >= self.explosion_duration: # Si l'explosion est terminee self.explosion_over = True 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'astéroïde est en train d'exploser # Dessiner les morceaux d'astéroïdes for i in range(len(self.pieces) - 1, -1, -1): piece = self.pieces[i] if piece[6] > 0: pyxel.circ(piece[0], piece[1], piece[2], piece[3]) # Dessiner un morceau d'astéroïde piece[0] += piece[4] # Mise à jour de la position horizontale du morceau piece[1] += piece[5] # Mise à jour de la position verticale du morceau else: # Si la durée de vie est écoulée, supprimer l'élément de la liste del self.pieces[i] # Dessiner les petites particules d'explosion for i in range(len(self.particles) - 1, -1, -1): particle = self.particles[i] if particle[5] > 0: pyxel.pset(particle[0], particle[1], particle[2]) # Dessiner une particule d'explosion particle[0] += particle[3] # Mise à jour de la position horizontale de la particule particle[1] += particle[4] # Mise à jour de la position verticale de la particule else: # Si la durée de vie est écoulée, supprimer l'élément de la liste del self.particles[i] 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 data(self): return [ self.name, self.radius, self.distance, self.color, self.information1, self.information2, self.game, self.orbital_period, self.moons, self.sun_position, self.ring_size, self.ring_color ] def check_hover_planet(self): """ Vérifie si la souris survole la planète """ distance_to_mouse = (self.x - pyxel.mouse_x) ** 2 + (self.y - pyxel.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 if self.angle < 2 * math.pi: 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 nom 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 soleil, la position du soleil, 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_data = [ {"name": "Mercure", "radius": 2, "distance": 30, "color": COLOR_GREY, "information1": "Mercure est la premiere planete du systeme solaire.", "information2": "La plus petite planete du systeme solaire.", "game": "game1", "orbital_period": 88, "moons": 0, "sun_position": self.sun_position, "ring_size": 0, "ring_color": None}, {"name": "Venus", "radius": 3, "distance": 45, "color": COLOR_YELLOW, "information1": "Venus est la deuxieme planete a partir du Soleil.", "information2": "Nommee d'apres la deesse romaine de l'amour et de la beaute.", "game": "game2", "orbital_period": 225, "moons": 0, "sun_position": self.sun_position, "ring_size": 0, "ring_color": None}, {"name": "Terre", "radius": 4, "distance": 60, "color": COLOR_BLUE, "information1": "La Terre est la troisieme planete a partir du Soleil.", "information2": "Le seul objet astronameique connu a abriter la vie.", "game": "game3", "orbital_period": 365, "moons": 1, "sun_position": self.sun_position, "ring_size": 0, "ring_color": None}, {"name": "Mars", "radius": 3, "distance": 80, "color": COLOR_RED, "information1": "Mars est la quatrieme planete a partir du Soleil.", "information2": "La deuxieme plus petite planete du systeme solaire.", "game": "game4", "orbital_period": 687, "moons": 2, "sun_position": self.sun_position, "ring_size": 0, "ring_color": None}, {"name": "Jupiter", "radius": 7, "distance": 110, "color": COLOR_LIGHTROSE, "information1": "Jupiter est la cinquieme planete a partir du Soleil.", "information2": "La plus grande planete du systeme solaire.", "game": "game5", "orbital_period": 4333, "moons": 79, "sun_position": self.sun_position, "ring_size": 0, "ring_color": None}, {"name": "Saturne", "radius": 6, "distance": 140, "color": COLOR_ROSE, "information1": "Saturne est la sixieme planete a partir du Soleil.", "information2": "La deuxieme plus grande du systeme solaire.", "game": "game6", "orbital_period": 10759, "moons": 82, "sun_position": self.sun_position, "ring_size": 2, "ring_color": COLOR_GREY}, {"name": "Uranus", "radius": 5, "distance": 170, "color": COLOR_CYAN, "information1": "Uranus est la septieme planete a partir du Soleil.", "information2": "L'atmosphere le plus froid du systeme solaire (−224°C).", "game": "game7", "orbital_period": 30688, "moons": 27, "sun_position": self.sun_position, "ring_size": 1, "ring_color": COLOR_GREY}, {"name": "Neptune", "radius": 4, "distance": 200, "color": COLOR_LIGHTBLUE, "information1": "Neptune est huitième planete, la plus eloignee du Soleil.", "information2": "Elle est nommee d'apres le dieu romain de la mer.", "game": "game8", "orbital_period": 60182, "moons": 14, "sun_position": self.sun_position, "ring_size": 0, "ring_color": None} ] # Création de la liste des planètes self.planets = [] for planet_data in self.planets_data: planet = Planet( planet_data["name"], planet_data["radius"], planet_data["distance"], planet_data["color"], planet_data["information1"], planet_data["information2"], planet_data["game"], planet_data["orbital_period"], planet_data["moons"], planet_data["sun_position"], planet_data["ring_size"], planet_data["ring_color"] ) self.planets.append(planet) 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, tailles 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 or self.asteroids[asteroid].explosion_over: 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)//15): 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.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.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.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) ######################################################## ### JEUX 1 : Balle sous gravité ######################################################## class Game1: """ Jeu de : Balle sous gravité """ def __init__(self, information_planet): self.information_planet = information_planet self.ball_x = pyxel.width // 2 self.ball_y = pyxel.height // 2 self.ball_radius = 5 self.ball_speed_x = 0 self.ball_speed_y = 0 self.game_over = False def reset(self): self.ball_x = pyxel.width // 2 self.ball_y = pyxel.height // 2 self.ball_speed_x = 0 self.ball_speed_y = 0 self.game_over = False def update(self): # Gravité dx = PYXEL_HEIGHT//2 - self.ball_x dy = PYXEL_WIDTH//2 - self.ball_y distance_squared = (dx * dx + dy * dy)//10000 distance = distance_squared ** 0.5 gravity_strength = self.information_planet[1]*1000 // distance_squared self.ball_speed_x += gravity_strength * dx // distance self.ball_speed_y += gravity_strength * dy // distance # Mise à jour de la position de la balle self.ball_x += self.ball_speed_x self.ball_y += self.ball_speed_y # Vérification des collisions avec les bords de l'écran if self.ball_x - self.ball_radius < 0 or self.ball_x + self.ball_radius > pyxel.width: self.ball_speed_x *= -0.9 if self.ball_y - self.ball_radius < 0 or self.ball_y + self.ball_radius > pyxel.height: self.ball_speed_y *= -0.9 def draw(self): # Dessiner la planète pyxel.circ(PYXEL_WIDTH//2, PYXEL_HEIGHT//2, self.information_planet[1], self.information_planet[4]) # Dessiner la balle pyxel.circ(self.ball_x, self.ball_y, self.ball_radius, 9) ######################################################## ### JEUX 2 : Esquiver obstacles (inspiré de Dino T-REX ######################################################## class Game2: """ Jeu de : Dinosaure """ def __init__(self, information_planet): self.information_planet = information_planet self.game_over = False def reset(self): pass def update(self): pass def draw(self): pass ######################################################## ### JEUX 3 : Saut de platformes (inspiré de Doodle Jump) ######################################################## class Player: def __init__(self, x, y): self.x = x self.y = y self.dy = 0 self.jump_power = -8 def update(self, platforms): self.y += self.dy self.dy += 1 # Check if the player is on a platform on_platform = False for platform in platforms: if ( self.y <= platform.y and self.y + 6 >= platform.y and self.x + 6 >= platform.x and self.x <= platform.x + platform.width ): on_platform = True self.y = platform.y - 6 self.dy = 0 break # Player movement if pyxel.btn(pyxel.KEY_UP) and on_platform: self.dy = self.jump_power def draw(self): pyxel.rect(self.x, self.y, 6, 6, 9) class Platform: def __init__(self, color, x, y, width=30, height=4): self.x = x self.y = y self.width = width self.height = height self.visible = True self.color = color def update(self): pass def draw(self): if self.visible: pyxel.rect(self.x, self.y, self.width, self.height, self.color) class Game3: def __init__(self, information_planet): self.information_planet = information_planet self.player = Player(PYXEL_WIDTH//2, PYXEL_HEIGHT-20) self.platforms = [Platform(self.information_planet[3], random.randint(0, PYXEL_WIDTH-30), random.randint(0, PYXEL_HEIGHT-30))] self.platforms.append(Platform(self.information_planet[3], PYXEL_WIDTH//2, PYXEL_HEIGHT-5)) self.score = 0 self.game_over = False def update(self): if pyxel.btn(pyxel.KEY_LEFT) and self.player.x > 0: if not any( self.player.y + 6 > platform.y and self.player.y < platform.y + platform.height and self.player.x - 1 <= platform.x + platform.width and self.player.x >= platform.x + platform.width for platform in self.platforms ): self.player.x -= 1 if pyxel.btn(pyxel.KEY_RIGHT) and self.player.x < 244: if not any( self.player.y + 6 > platform.y and self.player.y < platform.y + platform.height and self.player.x + 7 >= platform.x and self.player.x + 7 < platform.x for platform in self.platforms ): self.player.x += 1 self.player.update(self.platforms) # Game over condition if self.player.y > 250: self.game_over = True def draw(self): pyxel.cls(0) self.player.draw() for platform in self.platforms: platform.draw() pyxel.text(5, 5, "SCORE : " + str(self.score), COLOR_WHITE) pyxel.text(5, 15, "PLANET : "+ str(self.information_planet[0]), COLOR_WHITE) ######################################################## ### JEUX 4 : ######################################################## class Game4: """ Jeu de : ? """ def __init__(self, information_planet): self.information_planet = information_planet self.game_over = False def reset(self): pass def update(self): pass def draw(self): pass ######################################################## ### LANCEMENT PROGRAMME / CHANGEMENTS ######################################################## class App: """ Classe du lancement du programme """ def __init__(self): pyxel.init(PYXEL_WIDTH, PYXEL_HEIGHT, fps=30) # Initialisation du systeme solaire self.solar_system = SolarSystem() self.end = End() self.game1 = None self.game2 = None self.game3 = None self.game4 = None # Initialisation de l'objet selectionne a None self.selected_object = None self.selected_planet = None self.game_selection = None self.game_selected = 0 # Definition des coordonnees et dimensions des boutons self.game1_button_x = 10 self.game1_button_y = 10 self.game1_button_width = 110 self.game1_button_height = 110 self.game2_button_x = 130 self.game2_button_y = 10 self.game2_button_width = 110 self.game2_button_height = 110 self.game3_button_x = 10 self.game3_button_y = 130 self.game3_button_width = 110 self.game3_button_height = 110 self.game4_button_x = 130 self.game4_button_y = 130 self.game4_button_width = 110 self.game4_button_height = 110 pyxel.mouse(True) 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: # Si l'univers est encore "existant", verification des clics sur les boutons de retour et d'action if self.selected_object: # Clic sur le bouton de retour if (return_button_x <= pyxel.mouse_x <= return_button_x + action_return_width and return_button_y <= pyxel.mouse_y <= return_button_y + action_return_height): self.selected_object = None # Clic sur le bouton d'action if (action_button_x <= pyxel.mouse_x <= action_button_x + action_button_width and action_button_y <= pyxel.mouse_y <= action_button_y + 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() self.selected_object = None elif isinstance(self.selected_object, Planet): # Lance le sélectionneur de jeu self.game_selection = True self.selected_object = None elif isinstance(self.selected_object, Sun): # Démarre le grand déchirement self.selected_object = None self.solar_system.year = 100 elif self.game_selection: if (self.game1_button_x <= pyxel.mouse_x <= self.game1_button_x + self.game1_button_width and self.game1_button_y <= pyxel.mouse_y <= self.game1_button_y + self.game1_button_height): self.game_selected = 1 elif (self.game2_button_x <= pyxel.mouse_x <= self.game2_button_x + self.game2_button_width and self.game2_button_y <= pyxel.mouse_y <= self.game2_button_y + self.game2_button_height): self.game_selected = 2 elif (self.game3_button_x <= pyxel.mouse_x <= self.game3_button_x + self.game3_button_width and self.game3_button_y <= pyxel.mouse_y <= self.game3_button_y + self.game3_button_height): self.game_selected = 3 elif (self.game4_button_x <= pyxel.mouse_x <= self.game4_button_x + self.game4_button_width and self.game4_button_y <= pyxel.mouse_y <= self.game4_button_y + self.game4_button_height): self.game_selected = 4 if self.game_selected != 0: self.game1 = Game1(self.selected_planet) self.game2 = Game2(self.selected_planet) self.game3 = Game3(self.selected_planet) self.game4 = Game4(self.selected_planet) self.game_selection = False 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 planet in self.solar_system.planets: if planet.planet_hovered: self.selected_object = planet self.selected_planet = planet.data() 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/jeux uniquement si aucun objet n'est sélectionné if not self.selected_object: if self.solar_system.year >= 100: # Dessine la fin de l'univers et les crédits si le jeu est fini self.end.update() elif self.game_selected == 1: # Si le joueur a perdu if self.game1.game_over: if pyxel.btnp(pyxel.MOUSE_BUTTON_LEFT): # Clic sur le bouton de retour if (return_button_x <= pyxel.mouse_x <= return_button_x + action_return_width and return_button_y <= pyxel.mouse_y <= return_button_y + action_return_height): self.game_selected = 0 self.game1.reset() # Clic sur le bouton d'action elif (action_button_x <= pyxel.mouse_x <= action_button_x + action_button_width and action_button_y <= pyxel.mouse_y <= action_button_y + action_button_height): # Vérification du type d'objet sélectionné self.game1.reset() else: self.game1.update() elif self.game_selected == 2: # Si le joueur a perdu if self.game2.game_over: if pyxel.btnp(pyxel.MOUSE_BUTTON_LEFT): # Clic sur le bouton de retour if (return_button_x <= pyxel.mouse_x <= return_button_x + action_return_width and return_button_y <= pyxel.mouse_y <= return_button_y + action_return_height): self.game_selected = 0 self.game2.reset() # Clic sur le bouton d'action elif (action_button_x <= pyxel.mouse_x <= action_button_x + action_button_width and action_button_y <= pyxel.mouse_y <= action_button_y + action_button_height): # Vérification du type d'objet sélectionné self.game2.reset() else: self.game2.update() elif self.game_selected == 3: # Si le joueur a perdu if self.game3.game_over: if pyxel.btnp(pyxel.MOUSE_BUTTON_LEFT): # Clic sur le bouton de retour if (return_button_x <= pyxel.mouse_x <= return_button_x + action_return_width and return_button_y <= pyxel.mouse_y <= return_button_y + action_return_height): self.game_selected = 0 self.game3.reset() # Clic sur le bouton d'action elif (action_button_x <= pyxel.mouse_x <= action_button_x + action_button_width and action_button_y <= pyxel.mouse_y <= action_button_y + action_button_height): # Vérification du type d'objet sélectionné self.game3.reset() else: self.game3.update() elif self.game_selected == 4: # Si le joueur a perdu if self.game4.game_over: if pyxel.btnp(pyxel.MOUSE_BUTTON_LEFT): # Clic sur le bouton de retour if (return_button_x <= pyxel.mouse_x <= return_button_x + action_return_width and return_button_y <= pyxel.mouse_y <= return_button_y + action_return_height): self.game_selected = 0 self.game4.reset() # Clic sur le bouton d'action elif (action_button_x <= pyxel.mouse_x <= action_button_x + action_button_width and action_button_y <= pyxel.mouse_y <= action_button_y + action_button_height): # Vérification du type d'objet sélectionné self.game4.reset() else: self.game4.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(return_button_x, return_button_y, action_return_width, action_return_height, COLOR_WHITE) pyxel.text(return_button_x + 5, return_button_y + 5, "Retour", COLOR_WHITE) pyxel.rectb(action_button_x, action_button_y, action_button_width, 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 nom 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(action_button_x + 5, 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(action_button_x + 5, action_button_y + 5, "Exploser", COLOR_WHITE) # Dessin de l'écran du soleil elif isinstance(self.selected_object, Sun): pyxel.text(action_button_x + 5, action_button_y + 5, "End.", COLOR_WHITE) elif self.game_selection: # Jeu 1 pyxel.rectb(self.game1_button_x, self.game1_button_y, self.game1_button_width, self.game1_button_height, COLOR_WHITE) pyxel.text(self.game1_button_x + 5, self.game1_button_y + 5, "JEU 1", COLOR_WHITE) # Jeu 2 pyxel.rectb(self.game2_button_x, self.game2_button_y, self.game2_button_width, self.game2_button_height, COLOR_WHITE) pyxel.text(self.game2_button_x + 5, self.game2_button_y + 5, "JEU 2", COLOR_WHITE) # Jeu 3 pyxel.rectb(self.game3_button_x, self.game3_button_y, self.game3_button_width, self.game3_button_height, COLOR_WHITE) pyxel.text(self.game3_button_x + 5, self.game3_button_y + 5, "JEU 3", COLOR_WHITE) # Jeu 4 pyxel.rectb(self.game4_button_x, self.game4_button_y, self.game4_button_width, self.game4_button_height, COLOR_WHITE) pyxel.text(self.game4_button_x + 5, self.game4_button_y + 5, "JEU 4", COLOR_WHITE) else: # Mise à jour du système solaire/jeux uniquement si aucun objet n'est sélectionné if not self.selected_object: if self.solar_system.year >= 100: # Dessine la fin de l'univers et les crédits si le jeu est fini self.end.draw() elif self.game_selected == 1: if self.game1.game_over: pyxel.cls(0) pyxel.text(90, 120, "Game Over", COLOR_ROSE) pyxel.rectb(return_button_x, return_button_y, action_return_width, action_return_height, COLOR_WHITE) pyxel.text(return_button_x + 5, return_button_y + 5, "Retour", COLOR_WHITE) pyxel.rectb(action_button_x, action_button_y, action_button_width, action_button_height, COLOR_WHITE) pyxel.text(action_button_x + 5, action_button_y + 5, "Rejouer", COLOR_WHITE) else: self.game1.draw() elif self.game_selected == 2: if self.game2.game_over: pyxel.cls(0) pyxel.text(90, 120, "Game Over", COLOR_ROSE) pyxel.rectb(return_button_x, return_button_y, action_return_width, action_return_height, COLOR_WHITE) pyxel.text(return_button_x + 5, return_button_y + 5, "Retour", COLOR_WHITE) pyxel.rectb(action_button_x, action_button_y, action_button_width, action_button_height, COLOR_WHITE) pyxel.text(action_button_x + 5, action_button_y + 5, "Rejouer", COLOR_WHITE) else: self.game2.draw() elif self.game_selected == 3: if self.game3.game_over: pyxel.cls(0) pyxel.text(90, 120, "Game Over", COLOR_ROSE) pyxel.text(90, 130, "SCORE : " + str(self.game3.score), COLOR_ROSE) pyxel.rectb(return_button_x, return_button_y, action_return_width, action_return_height, COLOR_WHITE) pyxel.text(return_button_x + 5, return_button_y + 5, "Retour", COLOR_WHITE) pyxel.rectb(action_button_x, action_button_y, action_button_width, action_button_height, COLOR_WHITE) pyxel.text(action_button_x + 5, action_button_y + 5, "Rejouer", COLOR_WHITE) else: self.game3.draw() elif self.game_selected == 4: if self.game4.game_over: pyxel.cls(0) pyxel.text(90, 120, "Game Over", COLOR_ROSE) pyxel.rectb(return_button_x, return_button_y, action_return_width, action_return_height, COLOR_WHITE) pyxel.text(return_button_x + 5, return_button_y + 5, "Retour", COLOR_WHITE) pyxel.rectb(action_button_x, action_button_y, action_button_width, action_button_height, COLOR_WHITE) pyxel.text(action_button_x + 5, action_button_y + 5, "Rejouer", COLOR_WHITE) else: self.game4.draw() else: # Dessin du système solaire self.solar_system.draw() # Lancement de l'application App()