Problème sur mon snake j'espere de tout coeur avoir de l'aide merci <3

Signaler
Messages postés
3
Date d'inscription
samedi 22 mai 2021
Statut
Membre
Dernière intervention
23 mai 2021
-
 Spirali -
Bonjour,

Pour un devoir scolaire notre prof nous avais demandais de créer un jeu vidéo, j'ai donc décidé de faire un petit snake en python] que je continue à améliorer après la date limite pour mon plaisir personnel. Le seul consigne c'était d'utiliser la POO.

j'ai donc fait ceci : ( désolé pour le programme long en espérant que quelqu'un ai le courage de m'aider ).

# Tout les print et les consignes sont désactivés.
################## Les modules utilisé ###################
import random # pour le changement de position de la pomme
import pygame # module principal à la création du jeu
import time # pour modifier la vitesse de jeu 
import numpy as np # pour créer des tableau servant à stocker les positions du corps du serpent





class Game:
    
    ################### All Variables & Données #####################
    
    #Cette classe va contenir les variables et les fonctions qui vont servir au fonctionnement du jeu
    def __init__(self):
        self.son_eatapple = pygame.mixer.Sound(r'Eat.wav')
        self.son_bonus = pygame.mixer.Sound(r'Bonus.wav')
        self.son_boost = pygame.mixer.Sound(r'SpeedBoost.wav')
        pygame.mixer.music.load(r'MenuMusic.mp3')
        pygame.mixer.music.play(-1)
        self.ecran = pygame.display.set_mode((600,450)) # Crée la taille de la zone de jeu ( longueur + largeur)
        pygame.display.set_caption('Projet MAMBA') # Titre de la fenêtre 
        self.jardin = pygame.image.load('Jardin.png')
        self.accueil = pygame.image.load('Accueil.png')
        icon = pygame.image.load('URSS Flag.png')
        self.Snake_Head = pygame.image.load("TeteMambaRose.png")
        self.BoostIMG = pygame.image.load("Boost.png")
        self.fois2 = pygame.image.load("x2.png")
        self.apple = pygame.image.load("pomme.png")
        pygame.display.set_icon(icon)
        self.jeu_encours = True
        self.serp_x = 300 # variable de position X qui est à l'initial à 200
        self.serp_y = 300 # variable de position Y qui est à l'initial à 200
        self.serp_dir_x = 0 # variable de direction X qui est à l'initial NEUTRE
        self.serp_dir_y = -10 # variable de direction Y qui est à l'initial NEUTRE
        self.serp_body = 10 # taille du corps du serpent
        self.apple_x = random.randrange(50,550,10) # Position X de la pomme
        self.apple_y = random.randrange(50,390,10) # Position Y de la pomme
        self.score = 0
        self.corps=np.zeros([2,2])
        self.corps[0,:]=[self.serp_x,self.serp_y+10]
        self.corps[1,:]=[self.serp_x,self.serp_y+20]
        self.bonus_x = random.randrange(50,550,10) # Position du Bonus
        self.bonus_y = random.randrange(50,390,10) # Position du bonus
        self.Fois_Deux_x = random.randrange(50,550,10) # Position du Bonus
        self.Fois_Deux_y = random.randrange(50,390,10) # Position du bonus
        self.bonus = 10 # Taille du bonus
        self.tps_jeu = 0.07
        self.bonus_vit = [False,False]
        self.menu = True
        self.game_over = True
        self.Fois_Deux = [False,False]
        self.Pause = False
        self.FD_taille= 10
        self.dir_z = True
        self.dir_s = False
        self.dir_q = False
        self.dir_d = False
        # self.pausee = pygame.image.load('pause.png')
        
    ############### Création de la limite ####################    
        
    def creer_limites(self): # Créer les limites du jeu la ou le serpent peut aller sans mourir.
                pygame.draw.rect(self.ecran,(255,255,255),(0,30,600,420),3) # bordure blanche de 3 d'épaisseur
    
    ############# Fonction permettant d'afficher le score ##############
    
    def scores(self,x,y):
        font = pygame.font.SysFont("Monospace", 15)
        aff_score = font.render("Score : " + str(self.score),True, (255,255,255))       
        self.ecran.blit(aff_score, (x,y))
    
    ###################### Fonction principale ########################
    
    def Prin_fonc(self): # gestion des évenements, et de l'affichage de ceux-ci dans le jeu grâce à une boucle while
        while self.menu:   
            
                ############### affichage #################
                
                self.ecran.blit(self.accueil, (0,0))
                pygame.display.flip()
                for evenement in pygame.event.get():
                    
                    ######################### FullScreen #########################
                    
                    if evenement.type == pygame.KEYDOWN:
                        if evenement.key == pygame.K_F11:
                            pygame.display.toggle_fullscreen()
                    
                    
                    ################ Quitter avec la croix rouge #################
                    
                    
                    if evenement.type == pygame.QUIT:
                        pygame.quit()
                    
                    ################# Lancer le jeu #################
                    
                    if evenement.type == pygame.KEYDOWN:
                        if evenement.key == pygame.K_RETURN:
                            
                            
                            #################### musiques #############################
                            pygame.mixer.music.stop()
                            pygame.mixer.music.unload()
                            pygame.mixer.music.load(r'Music.mp3')
                            pygame.mixer.music.play(-1)
                            while self.jeu_encours:    
                                    for evenement in pygame.event.get():
                                        # print(evenement) # Le terminal va print chaque evenement qui se passe dans la zone de jeu 
                                                         # En l'occurence a ce stade du développement de mon snake il va afficher 
                                                         #la position du curseur ( si il y a quelque chose ou pas dans l'encadré )
                                        
                                        ############## Leave avec la croix rouge ################
                                        
                                        # print(self.serp_x,self.serp_y,self.serp_dir_x,self.serp_dir_y)
                                        if evenement.type == pygame.QUIT: # Si le programme détecte l'évenement QUIT ( qui sert a quitter la fenêtre si on clique sur la croix rouge)
                                            pygame.quit()
                                        
                                        ############## Leave avec Échap #################
                                        
                                        if evenement.type == pygame.KEYDOWN: 
                                            if evenement.key == pygame.K_BACKSPACE:
                                                pygame.quit()
                                        
                                            
                                        ############### Assignation des touches #################    
                                            
                                        if evenement.type == pygame.KEYDOWN:
                        
                                                
                                                ################## Directions ###################
                        
                        
                                                if evenement.key == pygame.K_d: # Créer la direction / le mouvement droite
                                                    if self.dir_q == True:
                                                        pass
                                                    else:
                                                        self.dir_z = False
                                                        self.dir_q = False
                                                        self.dir_s = False
                                                        self.dir_d = True
                                                        self.serp_dir_x = 10
                                                        self.serp_dir_y = 0
                                                        # print('Droite')
                        
                                                if evenement.key == pygame.K_q: # Créer la direction / le mouvement gauche
                                                    if self.dir_d == True:
                                                        pass
                                                    else:
                                                        self.dir_z = False
                                                        self.dir_d = False
                                                        self.dir_s = False
                                                        self.dir_q = True
                                                        self.serp_dir_x = -10
                                                        self.serp_dir_y = 0
                                                        # print('Gauche')
                        
                                                if evenement.key == pygame.K_s: # Créer la direction / le mouvement bas
                                                    if self.dir_z == True:
                                                        pass
                                                    else:
                                                        self.dir_z = False
                                                        self.dir_q = False
                                                        self.dir_d = False
                                                        self.dir_s = True
                                                        self.serp_dir_x = 0
                                                        self.serp_dir_y = 10
                                                        # print('bas')
                        
                                                if evenement.key == pygame.K_z: # Créer la direction / le mouvement haut
                                                    if self.dir_s == True:
                                                        pass
                                                    else:
                                                        self.dir_q = False
                                                        self.dir_d = False
                                                        self.dir_s = False
                                                        self.dir_z = True
                                                        self.serp_dir_x = 0
                                                        self.serp_dir_y = -10
                                                    # print('haut')
                                                
                                                
                                                ################## Pause ###################    
                                                
                                                # if evenement.key == pygame.K_p:
                                                #     print('ça marche')
                                                #     self.Pause = True
                                                #     while self.Pause:
                                                #         time.sleep(2)
                                                #         if evenement.type == pygame.KEYDOWN:
                                                #             if evenement.key == pygame.K_p:
                                                #                 self.Pause = False
                                                #             else:
                                                #                 pass
                                                                
                                                    
                                                    
                                    ############## Mort si le serpent s'auto mange #############                           
                                                    
                                    for corps_num in range(self.corps.shape[0]): # mort si il touche son propre corps
                                        if all(self.corps[corps_num,:]==[self.serp_x,self.serp_y]):
                                            pygame.quit()
                                            self.jeu_encours = False
                         
                                    ############# Mort si le serpent touche les bords #############         
                                    
                                    if self.serp_x <= 0 or self.serp_x >= 600 \
                                        or self.serp_y <=30 or self.serp_y >= 450: # définie la limite que le serpent peut aller
                                                pygame.quit()
                                                self.jeu_encours = False
                                                
                                    ################# Bonus de vitesse ################            
                                    
                                    if self.serp_y == self.bonus_y and self.serp_x == self.bonus_x: # Changement d'emplacement du bonus et fonctionnement de celle ci.
                                        start_bonus = time.time() # début du compteur en enregsitrement l'heure au moment ou le serpent mange le bonus
                                        self.bonus_vit = [True,True] # fais en sorte que le bonus sois fonctionnel et sois hors de l'écran
                                        self.tps_jeu -= 0.03 # augmente la vitesse du jeu 
                                        self.son_boost.play()
                                        self.bonus_x = 580 # Va déplacer le bonus hors du jeu
                                        self.bonus_y = 10
                                        
                                    if self.bonus_vit[0]: # si 10 secondes ne se sont pas écoulé gardé la vitesse puis la remettre à la vitesse originale
                                        if time.time() - start_bonus > 10:
                                            self.tps_jeu += 0.03 # ralenti le jeu
                                            self.bonus_vit[0] = False
                                            self.bonus_x = -100
                                            self.bonus_y = -100
                                        
                                    if self.bonus_vit[1]: # Si les 20 secondes ne sont pas passé à partir du moment où le serpent mange le bonus ... toujours laissé le bonus hors du jeu
                                        if time.time() - start_bonus > 20:
                                            self.bonus_vit[1] = False # les 20 secondes sont passées
                                            self.bonus_x = random.randrange(50,570,10) # lui demanderde creer deux coordonnées random
                                            self.bonus_y = random.randrange(50,390,10)
                                    # print(self.bonus_x,self.bonus_y, self.bonus_vit) # vérification
                                    
                                    ################# Bonus de points ################            
                                    
                                    if self.serp_y == self.Fois_Deux_y and self.serp_x == self.Fois_Deux_x: # Changement d'emplacement du bonus et fonctionnement de celle ci.
                                        start_bonus = time.time() # début du compteur en enregsitrement l'heure au moment ou le serpent mange le bonus
                                        self.Fois_Deux = [True,True] # fais en sorte que le bonus sois fonctionnel et sois hors de l'écran
                                        self.Fois_Deux_x = 565 # Va déplacer le bonus hors du jeu
                                        self.Fois_Deux_y = 10
                                        self.son_bonus.play()
                                        
                                        
                                    if self.Fois_Deux[0]: 
                                        if time.time() - start_bonus > 10:
                                            self.Fois_Deux[0] = False
                                            self.Fois_Deux_x = -100
                                            self.Fois_Deux_y = -100
                                        
                                    if self.Fois_Deux[1]: # Si les 20 secondes ne sont pas passé à partir du moment où le serpent mange le bonus ... toujours laissé le bonus hors du jeu
                                        if time.time() - start_bonus > 30:
                                            self.Fois_Deux[1] = False # les 20 secondes sont passées
                                            self.Fois_Deux_x = random.randrange(50,570,10) # lui demanderde creer deux coordonnées random
                                            self.Fois_Deux_y = random.randrange(50,390,10)
                                            
                                    
                                                
                                    ################# réarrangement des positions du serpent dans le tableau ##################         
                                    
                                    self.corps=np.roll(self.corps,1,axis=0)
                                    self.corps[0,:]=[self.serp_x, self.serp_y]
                                    
                                    ################ Direction & vitesse du jeu #################
                                    
                                    self.serp_x += self.serp_dir_x # change la position de la tete du serpent
                                    self.serp_y += self.serp_dir_y # change la position de la tete du serpent
                                    time.sleep(self.tps_jeu) # Sert a timer le jeu ... pour que le serpent fasse des mouvements toutes les x secondes car sinon le serpent fait de géant bond et saute la pomme
                                    
                                    ################# Système Pomme ##################
                                    
                                    if self.serp_y == self.apple_y and self.serp_x == self.apple_x: # Changement d'emplacement de la pomme
                                    
                                        # print("OK JE L'AI GRAILLE")
                                        self.apple_x = random.randrange(50,570 ,10)
                                        self.apple_y = random.randrange(50,390,10)
                                        self.son_eatapple.play()
                                        
                                        if self.Fois_Deux[0]:
                                            self.score += 20
                                        elif self.Fois_Deux[0] == False:
                                            self.score += 10
                                        # print(self.score)
                                        self.new_corps = np.zeros([self.corps.shape[0]+1,2])
                                        self.new_corps[:self.corps.shape[0],:] = self.corps
                                        self.corps = self.new_corps
                                    
                                    ############## couleur & background ################
                                    
                                    self.ecran.fill((0,0,0)) 
                                    self.ecran.blit(self.jardin, (0,30)) # Pour créer un image en arrière plan

                                    ################# Corps : Boost, Pomme, Tête du serpent & Double point #################
    
                                    self.ecran.blit(self.apple,(self.apple_x,self.apple_y)) 
                                    self.ecran.blit(self.fois2,(self.Fois_Deux_x,self.Fois_Deux_y))
                                    self.ecran.blit(self.BoostIMG, (self.bonus_x, self.bonus_y))
                                    self.ecran.blit(self.Snake_Head, (self.serp_x, self.serp_y))
                                    
                                    ################### Création des nouveaux corps du serpent #####################
                                    
                                    for corps_num in range(self.corps.shape[0]): # Affichage corps
                                        # print(self.corps[corps_num,0],self.corps[corps_num,1])
                                        pygame.draw.rect(self.ecran,(70,50,0), 
                                        (self.corps[corps_num,0],self.corps[corps_num,1],self.serp_body,self.serp_body)) 
                                    
                                    ########################## limites #####################
                                    self.creer_limites() # Créer les limites du jeu la ou le serpent peut aller sans mourir.
                                    
                                    ####################### Affichage du score ##############
                                    
                                    self.scores(30,5)
                                    
                                    pygame.display.flip() # Mettre à jour ce qui est affiché sur l'écran
        




if __name__ == '__main__':
    
    pygame.init()
    Game().Prin_fonc()
    pygame.quit()
    print('ok')


Mes problèmes sont donc:

- Comment faire pour ouvrir une nouvelle fenêtre en python ? parce que pour le moment tout ce que j'ai fait c'est superposé le background sur l'image que j'avais mis pour l'accueil. j'aimerai bien enfaites faire un onglet de Game_Over par situation (touche sa propre queue, touche les bords et un secret).

- Ensuite j'ai une erreur qui s'affiche sur d'autre logiciel ou quand je créer un .exe de ce fichier:



- L'ancien problème venait des sons va savoir pourquoi mais je l'ai corriger en rajoutant r' devant.

- Et surement le dernier point a chaque fin de programme le logiciel me met un message d'erreur concernant le ecran.fill ( ligne 294 ) et le print de fin ne s'affiche jamais donc je n'ai pas de confirmation.

Merci beaucoup de ton / votre aide ( à tous ) j'espère avoir une réponse venant de vaillant programmateur ayant le courage de lire le beau bordel que j'ai fait ( PS je suis en terminale donc moi et programmation ct pas encore trop trop ça il y a quelque années donc patapé les puristes du python xDDD ) Ce serait très aimable de votre part de m'aider car ce programme pourrait faire en sorte qu'il y ai de plus en plus d'élève voulant faire programmateur étant donné que ce programme finis sera montrer par mon prof à d'autre classe pour les futurs années.

Passez donc une bonne matinée / journée / soirée. merci encore :D

2 réponses

Messages postés
16058
Date d'inscription
lundi 9 juin 2008
Statut
Contributeur
Dernière intervention
19 juin 2021
867
bonjour,
je pense qu'il est préférable que tu fasses, pour chacun de tes soucis, un programme beaucoup plus court qui illustre ce soucis.
Messages postés
3
Date d'inscription
samedi 22 mai 2021
Statut
Membre
Dernière intervention
23 mai 2021

import pygame
import pygame

class Game:
    def __init__(self):
        self.ecran = pygame.display.set_mode((800,600))
        self.jeu_encours = True
        self.image = pygame.image.load(r'UneImage.png')

    def Prin_fonc(self):
        while self.jeu_encours:    
            for evenement in pygame.event.get():
                if evenement.type == pygame.QUIT: 
                    pygame.quit()
            
            self.ecran.fill((0,0,0))
            self.ecran.image.blit(self.image, (0,0))
            pygame.display.flip()

if __name__ == '__main__':
    
    pygame.init()
    Game().Prin_fonc()
    print('ok')
    
   



Si par exemple j'ai ce programme ... il est censer ( et le fait ) créer une fenêtre noire avec une image ( dont je n'ai pas mit le vrai nom car vous n'avez pas l'image en question et donc ne peut marcher dans tout les cas ). Comment faire en sorte de créer une autre fenêtre que celle actuelle ce ferme et qu'une nouvelle se lance ... doit-je créer plusieurs class une pour le menu une pour le game over et une autre pour le jeu ? ou alors y a-t-il une méthode pour faire disparaitre tout ce qu'il y a à l'écran et stopper tout le fonctionnement du snake ( car dans la logique le jeu continue en arriere plan même si je superpose une image comme je l'ai fait dans mon prog principal )
>
Messages postés
3
Date d'inscription
samedi 22 mai 2021
Statut
Membre
Dernière intervention
23 mai 2021

Nul besoin d'images pour faire un simple exemple.

import pygame

class Window:
    def __init__(self, size=(800, 600), color=(0, 0, 0)):
        self.screen = pygame.display.set_mode((800,600))
        self.screen.fill(color)
        pygame.display.update()
        self.running = True
        self.events = {}

    def run(self):
        while self.running:
            for evt in pygame.event.get():
                if evt.type == pygame.QUIT:
                    self.running = False
                elif evt.type in self.events:
                    self.events[evt.type]()

    def close(self):
        self.running = False


class Game:
    def __init__(self):
        self.win = Window(color=(255, 0, 0))
        self.win.events[pygame.MOUSEBUTTONDOWN] = self.test
        self.win.run()

    def test(self):
        self.win.close()
        self.win2 = Window(color=(255, 255, 0))
        self.win2.run()


if __name__ == '__main__':
    game = Game()
    pygame.quit()


Comme tu peux visualiser, il y a création d'une fenêtre rouge, la classe windows dispose d'un attribut permettant d'ajouter une action sur un event particulier, ici un simple clic souris pour faire un appel à la méthode test de la classe Game qui fait l'action de fermer la fenêtre rouge et en ouvrir une autre, jaune cette fois-ci.
Est utilisé win2 pour la seconde, mais on aurait tout aussi bien pu réutiliser l'attribut win.
Bonsoir.

>>>Comment faire pour ouvrir une nouvelle fenêtre en python ? parce que pour le moment tout ce que j'ai fait c'est superposé le background sur l'image que j'avais mis pour l'accueil. j'aimerai bien enfaites faire un onglet de Game_Over par situation (touche sa propre queue, touche les bords et un secret).

En python, je ne sais pas, mais avec pygame, ben simplement en créant une nouvelle fenêtre non ?
Maintenant, je ne suis pas certain que ce soit mieux de faire moult fenêtres plutôt que de tout mettre dans une seule et afficher ce en adéquation avec ce qu'il se passe dans le jeu.


>>>Ensuite j'ai une erreur qui s'affiche sur d'autre logiciel ou quand je créer un .exe de ce fichier:

Généralement, il faut inclure toutes les ressources nécessaires aux fonctionnement de l'application lorsqu'on crée un exécutable, cette erreur ressemble à une ressource non trouvée, images, fichiers audios ont-ils été inclus lors de sa création ?

>>>Et surement le dernier point a chaque fin de programme le logiciel me met un message d'erreur concernant le ecran.fill ( ligne 294 ) et le print de fin ne s'affiche jamais donc je n'ai pas de confirmation.

Je verrais bien que cette erreur est due à un pygame.quit() préalable, donc forcément ecran.fill va faire que ça plante si la fenêtre n'existe plus, mais comme tu ne spécifies pas l'erreur, ce n'est qu'hypothèse.
Messages postés
3
Date d'inscription
samedi 22 mai 2021
Statut
Membre
Dernière intervention
23 mai 2021

Tu parles de quel erreur la ? le fait que ça ne m'affiche jamais le print('ok') ? a cause du self.ecran.fill(0,0,0) ?
>
Messages postés
3
Date d'inscription
samedi 22 mai 2021
Statut
Membre
Dernière intervention
23 mai 2021

Je ne sais pas, puisque c'est toi qui parle d'erreur ! Laquelle on ne sait ce qu'elle raconte, puique tu ne le dis pas. Et sans, comment veux-tu que l'on sache ?