Salut tout le monde j'espere que vous aller bien et que vous avez passer de Joyeuses Fetes ! Meme si il est un peut tard, mieux vaut tard que jamais !

Bon bref , je suis la car j'ai un petit probleme:

Je suis en train de faire un jeu ( avec pygame) et lorsque j'appuye sur "a" je donne un coup d'épée ( c'est le principe) mais je me met a mon "point de spown "

c'est un peut genant  je preffererait qu'il reste la ou il est, ce pour quoi, je vous le demande

Merci d'avence !

Bonjour! Bonne fêtes à toi aussi!

Sinon, pour ce qui est de ton problème, tu ne voudrais pas mettre un petit code?

Et puis "point de spown" n'a aucune signification... donc si tu ne nous aide pas à t'aider, on peut plus rien pour toi. (même si on peut toujours te donner des petites pistes à l'aveugle)

ok voila ce qui concerne l'épée ( désoler pour mon retard .. quand je suis aller voire les réponse la , juste avant, j'ai vue qu'il n'y avait pas le message que j'avais mis ( j'avais oublier de cliquer sur "Répondre" :/ ))

elif event.type == KEYDOWN:
    elif event.key == K_a:
                    dk = Perso("link_droite_épée.png",       "link_gauche_épée.png", "link_haut_épée.png",  "link_bas_épée.png", niveau)

elif event.type == KEYUP:
                if event.key == K_a:
                    dk = Perso("dk_droite.png", "dk_gauche.png", "dk_haut.png", "dk_bas.png", niveau)

Voila Merci d'avence !

Mec, j'veux pas paraître lourd, mais là ça ne change pas grand chose, il n'y a pas assez de code pour qu'on puisse clairement dire où est l'erreur, mais je vais quand même essayer...

Je dirais qu'à la place de recréer ta classe Perso avec les nouvelles images, tu devrais simplement changer les 4 premiers arguments que tu passe à ta classe.

Si je ne me trompe pas, je dirais que ta classe commence avec quelque chose comme

class Perso(object):
    def __init__(self,epee1,epee2,epee3,epee4,niveau):
        self.epee1=epee1
        self.epee2=epee2
        self.epee3=epee3
        self.epee4=epee4

donc je dirais qu'à la place de faire

elif event.type == KEYDOWN:
    elif event.key == K_a:
                    dk = Perso("link_droite_épée.png",       "link_gauche_épée.png", "link_haut_épée.png",  "link_bas_épée.png", niveau)
 
elif event.type == KEYUP:
                if event.key == K_a:
                    dk = Perso("dk_droite.png", "dk_gauche.png", "dk_haut.png", "dk_bas.png", niveau)

tu devrais faire quelque chose comme

elif event.type == KEYDOWN:
    if event.key == K_a:
        dk.epee1 = "link_droite_épée.png"
        dk.epee2 = "link_gauche_épée.png"
        dk.epee3 = "link_haut_épée.png"
        dk.epee4 = "link_bas_épée.png"

 et idem pour KEYUP...

Bon, après je ne peux pas être sure de l'exactitude de ces info pour les raisons expliquées plus haut.

-
Edité par baltoo 14 janvier 2014 à 7:19:16

Salut

Merci beaucoup ton idée est vraiment bien mais maintenat que je l'ai mis pour le keydown et le keyup il m'affiche un message d'erreur quand j'appuye sur "a" (pour declancher l'épée , je ne peut plus bouger , le programme quitte en me disant :

Traceback (most recent call last):
  File "./jeutest.py", line 149, in <module>
    fenetre.blit(dk.direction, (dk.x, dk.y))  # dk.direction = l'image dans la bonne direction
TypeError: argument 1 must be pygame.Surface, not str

Bonjour,

désolé, mais là si tu ne sais pas lire une erreur, c'est vraiment chaud...

Bref, si tu poste le code source, je te le dé-bug vue le genre d'erreur que  c'est ça devrait aller vite...

Si tu veux vraiment que quelqu'un t'aide,poste des codes sources, car on ne peut (presque)rienfaire sans ça...

Ici c'est clair, ta variable dk.direction contiens une str au lieu d'une Surface.

#!/usr/bin/env python
#_*_ coding:Latin _*_






import pygame
from pygame.locals import *
from pygame.mixer import *
from classes2 import *
from constantes2 import *
from inventaire import *

pygame.init()
pygame.mixer.init()





#Ouverture de la fenêtre Pygame (carré : largeur = hauteur)
fenetre = pygame.display.set_mode((cote_fenetre, cote_fenetre))
#Icone

#Titre
pygame.display.set_caption(titre_fenetre)
pygame.key.set_repeat(30, 300)

#BOUCLE PRINCIPALE
continuer = 1
while continuer:    
    #Chargement et affichage de l'écran d'accueil
    accueil = pygame.image.load(image_accueil).convert()
    fenetre.blit(accueil, (0,0))
  
    #Rafraichissement
    pygame.display.flip()

    #On remet ces variables à 1 à chaque tour de boucle
    continuer_jeu = 1
    continuer_accueil = 1
    
    #BOUCLE D'ACCUEIL
    while continuer_accueil:
        
        #Limitation de vitesse de la boucle
        pygame.time.Clock().tick(30)
    
        for event in pygame.event.get():
        
            #Si l'utilisateur quitte, on met les variables 
            #de boucle à 0 pour n'en parcourir aucune et fermer
            if event.type == QUIT or event.type == KEYDOWN and event.key == K_ESCAPE:
                continuer_accueil = 0
                continuer_jeu = 0
                continuer_accueil2 = 0
                continuer = 0
             # Variable choix du niveau
                choix = 0
            if event.type == KEYDOWN:
                if event.key == K_z:
                    continuer_accueil = 0
                    choix = 'n1'


            
            
        

    #on vérifie que le joueur a bien fait un choix de niveau
    #pour ne pas charger s'il quitte
    if choix != 0:
        #Chargement du fond
        fond = pygame.image.load(image_fond).convert()

        #Génération d'un niveau à partir d'un fichier
        niveau = Niveau(choix)
        niveau.generer()
        niveau.afficher(fenetre)

        #Création de Link
        dk = Perso("dk_droite.png","dk_gauche.png","dk_haut.png","dk_bas.png", niveau)


                
    #BOUCLE DE JEU
    while continuer_jeu:
        
        #Limitation de vitesse de la boucle
        pygame.time.Clock().tick(30)
    
        for event in pygame.event.get():
        
            #Si l'utilisateur quitte, on met la variable qui continue le jeu
            #ET la variable générale à 0 pour fermer la fenêtre
            if event.type == QUIT:
                continuer_jeu = 0
                continuer = 0
            


            elif event.type == KEYDOWN:
                #Si l'utilisateur presse Echap ici, on revient seulement au menu
                if event.key == K_ESCAPE:
                    continuer_jeu = 0
                   
                
                #Touches de déplacement de Link
                
                elif event.key == K_RIGHT:
                    dk.deplacer('droite')
                elif event.key == K_LEFT:
                    dk.deplacer('gauche')
                elif event.key == K_UP:
                    dk.deplacer('haut')
                elif event.key == K_DOWN:
                    dk.deplacer('bas')  
            
                if event.key == K_a:
                    dk.droite = "link_droite_épée.png"
                    dk.gauche = "link_gauche_épée.png"
                    dk.haut = "link_haut_épée.png"
                    dk.bas = "link_bas_épée.png"
                
            elif event.type == KEYUP:
                if event.key == K_a:
                    dk.droite = "dk_droite.png"
                    dk.gauche = "dk_gauche.png"
                    dk.haut = "dk_haut.png"
                    dk.bas = "dk_bas.png"
                    
                
                    

                     #Affichages aux nouvelles positions
        fenetre.blit(fond, (0, 0))
        niveau.afficher(fenetre)
        fenetre.blit(dk.direction, (dk.x, dk.y))  # dk.direction = l'image dans  
                                                  #la bonne direction
        pygame.display.flip()
        
        
        

#!/usr/bin/python
#_*_ coding:Latin _*_




import pygame
from pygame.locals import *

#Paramètres de la fenêtre
nombre_sprite_cote = 16
taille_sprite = 26
cote_fenetre = nombre_sprite_cote * taille_sprite

#Personnalisation de la fenêtre
titre_fenetre = "ZELDA prisonnier of dimension"
#son


#Listes des images du jeu
image_accueil = "accueil1.jpg"
image_fond = "village1.jpg"
image_mur = "mur.png"
image_depart = "depart.png"
image_arrivee = "arrivee.png"
image_pique = "pique.png"
image_sol = "sol.png"
image_herbe = "herbe.png"
image_maison = "maison.png"
image_mur2 = "mur2.png"
image_accueil2 = "accueil2.jpg"

#!/usr/bin/python
#_*_ coding:Latin _*_


import pygame
from pygame.locals import * 
from constantes2 import *

class Niveau:
    """Classe permettant de créer un niveau"""
    def __init__(self, fichier):
        self.fichier = fichier
        self.structure = 0
        dk_x = 340
    
    def generer(self):
        """Méthode permettant de générer le niveau en fonction du fichier.
        On crée une liste générale, contenant une liste par ligne à afficher""" 
        #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):
        """Méthode permettant d'afficher le niveau en fonction 
        de la liste de structure renvoyée par generer()"""
        #Chargement des images (seule celle d'arrivée contient de la transparence)
        mur = pygame.image.load(image_mur).convert()
        depart = pygame.image.load(image_depart).convert()
        arrivee = pygame.image.load(image_arrivee).convert_alpha()
        pique   = pygame.image.load(image_pique).convert_alpha()
        sol = pygame.image.load(image_sol).convert_alpha()
        herbe = pygame.image.load(image_herbe).convert_alpha()
        maison = pygame.image.load(image_maison).convert_alpha()
        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 == 'm1':          #m = Mur
                    fenetre.blit(mur, (x,y))
                elif sprite == 'd':        #d = Départ
                    fenetre.blit(depart, (x,y))
                elif sprite == 'a':        #a = Arrivée
                    fenetre.blit(arrivee, (x,y))
                elif sprite =='p':
                    fenetre.blit(pique, (x,y))
                elif sprite == 's':
                    fenetre.blit(sol, (x,y))
                elif sprite == 'h':
                    fenetre.blit(herbe, (x,y))
                elif sprite == 'w':
                    fenetre.blit(maison,(x,y))
                elif sprite == 'v':
                    fenetre.blit(mur2,(x,y))



                num_case += 1
            num_ligne += 1
            
            
            
            
class Perso(object):
    """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 = 0
        self.case_y = 2
        self.x = 0
        self.y = 50
        #Direction par défaut
        self.direction = self.droite
        #Niveau dans lequel le personnage se trouve 
        self.niveau = niveau
    
    
    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):
                #On vérifie que la case de destination n'est pas un mur
                if self.niveau.structure[self.case_y][self.case_x+1] != 'm':
                    if self.niveau.structure[self.case_y][self.case_x+1] != 'w':
                        if self.niveau.structure[self.case_y][self.case_x+1] != '1':
                            if self.niveau.structure[self.case_y][self.case_x+1] != 'v':                      
                    #Déplacement d'une case
                                self.case_x += 1
                    #Calcul de la position "réelle" en pixel
                                self.x = self.case_x * taille_sprite
            #Image dans la bonne direction
                                self.direction = self.droite
        
        #Déplacement vers la gauche
        if direction == 'gauche':
            if self.case_x > 0:
                if self.niveau.structure[self.case_y][self.case_x-1] != 'm':
                    self.case_x -= 1
                    self.x = self.case_x * taille_sprite
                    self.direction = self.gauche
        
        #Déplacement vers le haut
        if direction == 'haut':
            if self.case_y > 0:
                if self.niveau.structure[self.case_y-1][self.case_x] != 'm':
                    if self.niveau.structure[self.case_y-1][self.case_x] != 'w':
                        if self.niveau.structure[self.case_y-1][self.case_x] != '1':
                            if self.niveau.structure[self.case_y-1][self.case_x] != 'v':
                                
                                self.case_y -= 1
                                self.y = self.case_y * taille_sprite
                                self.direction = self.haut
        
        #Déplacement vers le bas
        if direction == 'bas':
            if self.case_y < (nombre_sprite_cote - 1):
                if self.niveau.structure[self.case_y+1][self.case_x] != 'm':
                    if self.niveau.structure[self.case_y+1][self.case_x] != 'w':
                        if self.niveau.structure[self.case_y+1][self.case_x] != '1':
                            if self.niveau.structure[self.case_y+1][self.case_x] != '1':
                    
                                self.case_y += 1
                                self.y = self.case_y * taille_sprite
                                self.direction = self.bas

       
                                if self.case_y == 4:
                                    print ("test")

Voila , et non je ne sait pas lire tout les message d'érreur je ne suis encore que débutant , merci

Bonjour!

Alors en effet, ta variable direction contiens bien une str quand tu appuies sur a:

if event.key == K_a:
    dk.droite = "link_droite_épée.png"
    dk.gauche = "link_gauche_épée.png"
    dk.haut = "link_haut_épée.png"
    dk.bas = "link_bas_épée.png"
elif event.type == KEYUP:
    if event.key == K_a:
        dk.droite = "dk_droite.png"
        dk.gauche = "dk_gauche.png"
        dk.haut = "dk_haut.png"
        dk.bas = "dk_bas.png"

vu que ta variable dk.direction pointe sur dk.haut, dk.bas etc...

bon, et sinon, je ne sais pas ce que t'as fais, mais ton msg d'erreur ne correspond pas à ton code source;

Et aussi, notre niveau n'est pas si éloigné, alors les messages d'erreur genre:

"ligne 149 ta variable dk.direction contient un str au lieu d'un pygame.Surface"

te sont normalement tout à fait compréhensible quand t'es capable de pondre un code comme celui qui tu montres.

Pour en revenir à l'erreur, il faut écrire quelque chose comme

dk.droite = pygame.image.load("link_droite_épée.png").convert_alpha()

J'ai l'impression que tu as fais un copier/coller de ce que j'ai posté (alors que je n'avais pas suffisamment d'info pour pondre un truc potable) sans même essayer de comprendre et de l'adapter...

J'avoue ne pas avoir testé car dessiner X images pour correspondre à ton jeu: c'est pas que ça ne m’emballe pas mais bon...

-
Edité par baltoo 16 janvier 2014 à 9:47:08

Ok merci tt le monde