Bien le bonsoir !

Cela fait quelques temps que je travaille sur un petit jeu, mais quand je veux récupérer les coordonnées de mes deux class "personnage" pour faire 'Si coord perso1 == coord perso 2 alors game over', le game over est instantané :(. Plus exactement, j'ai mis: 

  if niveau.structure[hero.case_y][hero.case_x] == niveau.structure[fan1.case_y][fan1.case_x]:

les codes des Class en dessous, ça va être long ^^'!

class Ennemi:
                
        def __init__(self, droite, gauche, haut, bas, niveau):
                self.droite1 = pygame.image.load(droite).convert_alpha()
                self.gauche1 = pygame.image.load(gauche).convert_alpha()
                self.haut1 = pygame.image.load(haut).convert_alpha()
                self.bas1 = pygame.image.load(bas).convert_alpha()
                self.case_x = random.randint(0,26)
                self.case_y = random.randint(0,23) 
                self.x = self.case_x*28
                self.y = self.case_y*28
                self.direction1 = self.gauche1
                self.niveau = niveau
                coord_ennemi = (0,0)
                
        def ennemi(self, direction1):
                if direction1 == 'droite':
                        if self.case_x < (nombre_sprite_cote - 1):
                                if self.niveau.structure[self.case_y][self.case_x+1] != 'm' and self.niveau.structure[self.case_y][self.case_x+1] != 'l' and self.niveau.structure[self.case_y][self.case_x+1] != 'g' :
                                        self.case_x += 1
                                        self.x = self.case_x * taille_sprite
                                        coord_ennemi = (self.x,self.y)
                                self.direction1 = self.droite1
                elif direction1 == 'gauche':
                        if self.case_x > 0:
                                if self.niveau.structure[self.case_y][self.case_x-1] != 'm' and self.niveau.structure[self.case_y][self.case_x-1] != 'l' and self.niveau.structure[self.case_y][self.case_x-1] != 'g':
                                        self.case_x -= 1
                                        self.x = self.case_x * taille_sprite
                                        coord_ennemi = (self.x,self.y)
                                self.direction1 = self.gauche1
                elif direction1 == 'haut':
                        if self.case_y > 0:
                                if self.niveau.structure[self.case_y-1][self.case_x] != 'm' and self.niveau.structure[self.case_y-1][self.case_x] != 'l' and self.niveau.structure[self.case_y-1][self.case_x] != 'g':
                                        self.case_y -= 1
                                        self.y = self.case_y * taille_sprite
                                        coord_ennemi = (self.x,self.y)
                                self.direction1 = self.haut1
                elif direction1 == 'bas':
                        if self.case_y < (nombre_sprite_cote - 1):
                                if self.niveau.structure[self.case_y+1][self.case_x] != 'm' and self.niveau.structure[self.case_y+1][self.case_x] != 'l' and self.niveau.structure[self.case_y+1][self.case_x] != 'g':
                                        self.case_y += 1
                                        self.y = self.case_y * taille_sprite
                                        coord_ennemi = (self.x,self.y)
                                self.direction1 = self.bas1

class Perso:
        """Classe permettant de créer un personnage"""
        def __init__(self, droite, gauche, haut, bas, niveau):
                #Sprites du personnage
                self.droite = pygame.image.load(droite).convert_alpha()
                self.gauche = pygame.image.load(gauche).convert_alpha()
                self.haut = pygame.image.load(haut).convert_alpha()
                self.bas = pygame.image.load(bas).convert_alpha()
                #Position du personnage en cases et en pixels
                self.case_x = 14
                self.case_y = 15
                self.x = 400
                self.y = 400
                #Direction par défaut
                self.direction = self.droite
                #Niveau dans lequel le personnage se trouve
                self.niveau = niveau
                coord_perso = (0,0)
                
        
        
        def deplacer(self, direction):
                """Methode permettant de déplacer le personnage"""
                
                #Déplacement vers la droite
                if direction == 'droite':
                        #Pour ne pas dépasser l'écran
                        if self.case_x < (nombre_sprite_cote - 1):
                                #Déplacement d'une case
                                self.case_x += 1
                                #Calcul de la position "réelle" en pixel
                                self.x = self.case_x * taille_sprite
                                coord_perso = (self.x,self.y)

                        #Image dans la bonne direction
                        self.direction = self.droite
                
                #Déplacement vers la gauche
                if direction == 'gauche':
                        if self.case_x > 0:
                                self.case_x -= 1
                                self.x = self.case_x * taille_sprite
                                coord_perso = (self.x,self.y)


                        self.direction = self.gauche
                
                #Déplacement vers le haut
                if direction == 'haut':
                        if self.case_y > 0:
                                self.case_y -= 1
                                self.y = self.case_y * taille_sprite
                                coord_perso = (self.x,self.y)

                        self.direction = self.haut
                
                #Déplacement vers le bas
                if direction == 'bas':
                        if self.case_y < (nombre_sprite_cote - 1):
                                self.case_y += 1
                                self.y = self.case_y * taille_sprite
                                coord_perso = (self.x,self.y)

                        self.direction = self.bas

class Niveau:
        def __init__(self, fichier):
                self.fichier = fichier
                self.structure = 0
        
        
        def generer(self):
                #On ouvre le fichier
                with open(self.fichier, "r") as fichier:
                        structure_niveau = []
                        #On parcourt les lignes du fichier
                        for ligne in fichier:
                                ligne_niveau = []
                                #On parcourt les sprites (lettres) contenus dans le fichier
                                for sprite in ligne:
                                        #On ignore les "\n" de fin de ligne
                                        if sprite != '\n':
                                                #On ajoute le sprite à la liste de la ligne
                                                ligne_niveau.append(sprite)
                                #On ajoute la ligne à la liste du niveau
                                structure_niveau.append(ligne_niveau)
                        #On sauvegarde cette structure
                        self.structure = structure_niveau
        
        
        def afficher(self, fenetre):
                #Chargement des images
                mur = pygame.image.load(image_mur).convert_alpha()
                
                #On parcourt la liste du niveau
                num_ligne = 0
                for ligne in self.structure:
                        #On parcourt les listes de lignes
                        num_case = 0
                        for sprite in ligne:
                                #On calcule la position réelle en pixels
                                x = num_case * taille_sprite
                                y = num_ligne * taille_sprite
                                if sprite == 'm':                  #m = Mur
                                        fenetre.blit(mur, (x,y))

                                num_case += 1
                        num_ligne += 1
                mur2 = pygame.image.load(image_mur2).convert_alpha()
                
                #On parcourt la liste du niveau
                num_ligne = 0
                for ligne in self.structure:
                        #On parcourt les listes de lignes
                        num_case = 0
                        for sprite in ligne:
                                #On calcule la position réelle en pixels
                                x = num_case * taille_sprite
                                y = num_ligne * taille_sprite
                                if sprite == 'l':                  #l = Mur 2
                                        fenetre.blit(mur2, (x,y))

                                num_case += 1
                        num_ligne += 1
                mur3 = pygame.image.load(image_mur3).convert_alpha()
                
                #On parcourt la liste du niveau
                num_ligne = 0
                for ligne in self.structure:
                        #On parcourt les listes de lignes
                        num_case = 0
                        for sprite in ligne:
                                #On calcule la position réelle en pixels
                                x = num_case * taille_sprite
                                y = num_ligne * taille_sprite
                                if sprite == 'g':                  #l = Mur 3
                                        fenetre.blit(mur3, (x,y))

                                num_case += 1
                        num_ligne += 1
                fin = pygame.image.load(image_fin).convert_alpha()
                num_ligne = 0
                for ligne in self.structure:
                        #On parcourt les listes de lignes
                        num_case = 0
                        for sprite in ligne:
                                #On calcule la position réelle en pixels
                                x = num_case * taille_sprite
                                y = num_ligne * taille_sprite
                                if sprite == 'f':                  #f = fin
                                        fenetre.blit(fin, (x,y))

                                num_case += 1
                        num_ligne += 1

J'espère que vous vous y retrouverez dans tout ça, et merci pour l'aide

Heu... Alors j'ai un peu du mal à comprendre car je débute encore dans python, mais il me semble ( après j'ai pas ton code principal ni ton fichier texte ) que ta condition vérifie si la lettre liée à la position de ton perso et celle liée à celle de ton ennemie sont les mêmes.

Tu comprends ? Tu ne vérifies pas si les coordonnées des persos se confondent, mais simplement si la lettre de la case sur laquelle ils se trouvent est la même, et normalement, si tu as bien géré l’empêchement de se trouver sur une case mur, ils se trouvent forcément les deux sur une case " sol " ( je ne sais pas comment tu as appelé ça, case " vide " peut-être ).

Du coup, la condition est toujours vérifiée.

Ce que tu voulais faire, qui est pourtant plus simple :

if hero.case_y == fan1.case_y and hero.case_x == fan1.case_x:

Il me semble que ce tu veux faire s'apparente à ça.

Mais tu remarqueras que le résultat n'est pas très concluant...

Pour gérer une collision, le mieux à faire est de se servir de l'objet rect de Pygame, je te laisse te renseigner sur son fonctionnement, il modifiera tout ton code mais tu verras il te serra bien pratique...

-
Edité par Grimmys 21 mai 2015 à 19:43:17

je vais tester ça merci

                if hero.x == fan21.x and hero.y == fan21.y:

Merci beaucoup !!!

bonne soirée