Partage

Bomberman

Prologue

<< 1 2 3 >>

Sujet résolu

28 juillet 2010 à 21:10:05

Je t'en montre un, basé sur un exemple que j'ai réalise lorsque j'ai découvert Pygame. Il est similaire à ton exemple : on doit bouger Mario en utilisant les flèches du clavier. Mais je n'ai pas pris la peine d'utiliser des images différentes selon les positions de Mario.

Voici le code (mis à jour à 0h00 pour qu'il soit plus compréhensible

# -*-coding:iso-8859-1 -*
import pygame 
from pygame.locals import *

class Joueur:
	def __init__(self, imageJoueur):
		try: #On tente de charger l'image
			self.surface = pygame.image.load(imageJoueur)
		except:
			pygame.quit()
			print("Erreur lors du chargement de l'image {0}".format(imageJoueur))
			raise SystemExit #S'il y a une erreur, on quitte
		self.surface.set_colorkey((128, 128, 128)) #La couleur transparente dans mon image (en l'occurence du gris)
		self.enMouvement, self.direction, self.position, self.anciennePosition = False, None, None, None

	def afficher(self,fenetre,position):
		""" Affiche l'image du joueur en <position> sur <fenetre> et efface l'image à l'ancienne position"""
		fenetre.fill((255,255,255), rect=self.anciennePosition)
		self.anciennePosition = self.position
		self.position = fenetre.blit(self.surface,position)

	def bouger(self,evenement,fenetre):
		"""Si le joueur a appuyé sur l'une des touches fléchées, bouge l'image du joueur"""
		if evenement.type == KEYDOWN and (evenement.dict["key"] is K_DOWN or K_UP or K_LEFT or K_RIGHT): #Si le joueur a appuyé sur l'une des touches fléchées
			self.enMouvement = True #Alors on est en mouvement
			self.direction = evenement.dict["key"] 
		elif evenement.type == KEYUP:  #S'il lâche, alors on est à l'arrêt
			self.enMouvement = False
		if self.enMouvement is True: #Si on est en mouvement
			if self.direction == K_DOWN:
				self.position.move_ip(0, 1)
			if self.direction == K_UP:
				self.position.move_ip(0, -1)
			if self.direction == K_LEFT:
				self.position.move_ip(-1, 0)
			if self.direction == K_RIGHT:
				self.position.move_ip(1, 0)
			if self.position.right >= fenetre.get_rect().width: #Si on est hors de la fenêtre en largeur
				self.position.move_ip(-1, 0) #On ajuste la position du joueur
			if self.position.top >= (fenetre.get_rect().height - self.position.height): #Si on est hors de la fenêtre en hauteur
				self.position.move_ip(0, -1)
			self.afficher(fenetre,self.position) #Affichage de l'image du joueur actualisé

class Jeu:
	def __init__(self):
		try: #On tente d'initialiser Pygame
			pygame.init()
		except pygame.error: #Si une erreur se produit, on arrête Pygame
			print("Une erreur s'est produite durant l'initialisation de Pygame, le programme ne peut donc pas être ouvert..")
			raise SystemExit
		try:
			self.fenetre = pygame.display.set_mode((1200, 600), pygame.DOUBLEBUF) #Initialisation de la fenêtre
		except pygame.error:
			raise SystemExit
		pygame.display.set_caption("Mon petit jeu")
		self.fenetre.fill((255,255,255)) #Couleur de fond de la fenêtre (du blanc)
	
	def verifierSiLeJeuDoitSeFermer(self,evenement):
		"""Retourne True si le joueur a appuyé sur Echap. ou a cliqué sur la croix """
		return (evenement.type == QUIT) or (evenement.type == KEYDOWN and evenement.dict["key"] == K_ESCAPE) 

	def executer(self):

		mario = Joueur("MarioSeul.png")
		mario.afficher(self.fenetre, (0,0))
		jeuFini = False
		while jeuFini is not True:
			evenement = pygame.event.poll()
			jeuFini = self.verifierSiLeJeuDoitSeFermer(evenement)
			mario.bouger(evenement,self.fenetre)
			pygame.display.flip()


if __name__ == "__main__":
	jeu = Jeu()
	jeu.executer()

Le principal se situe dans la classe Joueur. Lors de l'initialisation, on créé un Rect self.position qui ne contient rien. Il servira à accuellir la position actuelle du joueur.

La boucle évènementielle apelle la méthode bouger qui analyse l'action du joueur. Si le joueur a appuyé sur une touche fléchée, elle fait appel à la méthode self.position.move_ip qui prend en paramètre un tuple (abscisse, ordonnée) indiquant de combien de pixels elle doit déplacer la position actuelle. Par exemple, indiquer (0,1) revient à avancer d'un pixel vers le bas, (-1,0) d'un pixel vers la gauche, et (1,1) d'un pixel vers le bas et la droite. Ainsi, on ajuste la position en fonction de l'action du joueur.

Une fois la position mise à jour, il nous reste à actualiser l'affichage avec la méthode afficher. Elle se charge d'effacer l'écran mais uniquement à la position précédente du joueur, et de blitter Mario à la position sur laquelle nous avons travaillé.

Et voilà !

realmagma

29 juillet 2010 à 9:11:29

Je vais paraître très 'chiant', mais je ne comprends pas du tout ton code.
Je me pose encore les même questions que précédement :euh:

.

P.S: C'est moi qui suis comme ça, il me faut (beaucoup?) d'exemples diférents pour bien comprendre comment cela fonctionne.
Aurais-tu un autre exemple (plus simple?)

.

Non, non pas le fouet... :pirate:

Je te remercie quand même pour tes explications (et puis les explications des autres zéro).

Anonyme

29 juillet 2010 à 9:55:11

Citation

Je vais paraître très 'chiant', mais je ne comprends pas du tout ton code.

Franchement sur ce dernier cas je te comprend

Voila un cas très simple avec la classe chat, tu te souviens de Nohar

class chat(object):
    def __init__(self, nom):
        self.nom=nom
    def get_nom(self):
        return self.nom
    def miauler(self, endroit):
        print "le chat miaule dans %s" %(endroit)

ch=chat("mistigri") # instancie la classe chat (important)
print "mon chat s\'appelle %s" %(ch.get_nom()) # appelle la méthode get_nom de la classe chat
ch.miauler("la cuisine") # appel de la méthode miauler de la classe chat

mon chat s'appelle mistigri
le chat miaule dans la cuisine

J'espère que ça ira mieux pour toi, personnellement j'ai eu du mal aussi avec la POO, je comprend tes difficultés.

realmagma

29 juillet 2010 à 10:47:39

En faite ce que je ne comprends pas, ce sont les utilisaion des Rect().

Quelle diférence il y a t'il entre un 'Rect()' et 'Surface()' ?
Comment initialiser un personnage comme étant un rect ?

monPerso = pygame.image.load("mario.PNG")
monPerso.get_rect

Donc ici mon perso est du type Rect() donc une surface.

Pour le bliter, je dois faire comme suis:

screen.blit(monPerso, monPerso.move(positionPerso))

-Mais comment faire pour garder la position de ma surface ?
-On cree une variable de quelle type?
-Dois-je m'inspirer de mon ancien code ?

-Dois-je crée une méthode pour deplacer mon perso, ou faut il mieux (à coups de if, elif) le créer dans ma boucle principale ?

Qui se lance pour répondre à toutes ces questions ?

Je vous remercie d'avance.

Anonyme

29 juillet 2010 à 10:59:19

Citation

Qui se lance pour répondre à toutes ces questions ?

Pas moi! Car je pense qu'il faut commencer par le commencement.

nohar

29 juillet 2010 à 12:05:00

Citation : realmagma

En faite ce que je ne comprends pas, ce sont les utilisaion des Rect().

Quelle diférence il y a t'il entre un 'Rect()' et 'Surface()' ?
Comment initialiser un personnage comme étant un rect ?
monPerso = pygame.image.load("mario.PNG")
monPerso.get_rect() # j'en profite pour corriger 

la classe Rect contient simplement un rectangle (dimensions + position), alors que la classe Surface peut être vue comme une image.
Lorsque tu appelles get_rect() sur une Surface, tu récupères un rectangle de mêmes dimensions que ta surface (la position retournée n'a aucune pertinence). Tu devrais stocker ce rectangle dans une variable "monPerso_rect".
Lorsque tu veux déplacer ton perso, tu appelles la méthode move() de ton objet "monPerso_rect".

Citation : realmagma

Donc ici mon perso est du type Rect() donc une surface.

Pour le bliter, je dois faire comme suis:
screen.blit(monPerso, monPerso.move(positionPerso))

Non, tu devrais plutôt faire :

monPerso_rect.topleft = ("60, 60") # je place le perso à la position (60,60)
monPerso_rect.y -= 10 # je bouge le perso de 10 pixels vers le haut
screen.blit(monPerso, monPerso_rect)

Le rectangle lors du "blit" permet de définir la position ET la dimension de l'image que tu blittes.

Citation : realmagma

-Mais comment faire pour garder la position de ma surface ?
-On cree une variable de quelle type?
-Dois-je m'inspirer de mon ancien code ?

-Dois-je crée une méthode pour deplacer mon perso, ou faut il mieux (à coups de if, elif) le créer dans ma boucle principale ?

Je pense que les indications que je viens de te donner peuvent te guider vers les réponses.

Zeste de Savoir, le site qui en a dans le citron !

zazapeta

30 juillet 2010 à 0:35:40

salut,

Hors-sujet : Ce lien peut surement t'aider :"http://www.labri.fr/perso/schlick/MIMSE/"

Niveau D -> les classes.

Certe il n'y a pas de tutoriel, mais ça pourra te permettre de te familiarisé avec les classes avec des petits exercices.

Cordialement.
Zazapeta.

realmagma

30 juillet 2010 à 16:01:26

Bonjour,

suivant ce que vous m'avez dit, j'ai retravailler mon code pour l'utilisation des rect(). J'ai dû supprimer les classes uniquement pour voir comment marchent les rect().

Mon code marche plutôt bien, mais j'avais exactement le même problème qu'avant.
Il ne fait que reculer ! Impossible de le bliter à droite, en bas ou à gauche !

Quelqu'un avait parler d'une pile d'évenements. Est-ce lié au fait que j'utilise un get() et non un poll() ?

while(continuer):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            continuer = False
        
        elif(event.type is pygame.KEYDOWN):
            
            if(pygame.key.name(pygame.K_UP)):  
                posJ.move_ip(0, -10)
        
            elif(pygame.key.name(pygame.K_DOWN)):               
                posJ.move_ip(0, -10)

            elif(pygame.key.name(pygame.K_RIGHT)):             
                posJ.move_ip(10, 0)

            elif(pygame.key.name(pygame.K_LEFT)):
                posJ.move_ip(-10, 0)
            
            screen.blit(monImageB, posJ)
            pygame.display.flip()
            #Effacement de l'ecran

zazapeta

30 juillet 2010 à 17:52:40

Salut,

Citation : realmagma

elif(event.type is pygame.KEYDOWN):

if(pygame.key.name(pygame.K_UP)):
posJ.move_ip(0, -10)

elif(pygame.key.name(pygame.K_DOWN)):
posJ.move_ip(0, -10)

Normal qu'il descende... tu effectue la meme action ,ie 'posJ.move_ip(0,-10)', que tu fasses K_UP ou K_DOWN...

Essaye :

while(continuer):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            continuer = False
        
        elif(event.type is pygame.KEYDOWN):
            
            if(pygame.key.name(pygame.K_UP)):  
                posJ.move_ip(0, -10)
        
            elif(pygame.key.name(pygame.K_DOWN)):               
                posJ.move_ip(0, 10) # ICI j'ai changé !!!

            elif(pygame.key.name(pygame.K_RIGHT)):             
                posJ.move_ip(10, 0)

            elif(pygame.key.name(pygame.K_LEFT)):
                posJ.move_ip(-10, 0)
            
            screen.blit(monImageB, posJ)
            pygame.display.flip()
            #Effacement de l'ecran

Bon courage.

nohar

30 juillet 2010 à 18:02:35

Ah et pour tester la touche pressée :

# ...
elif event.type == pygame.KEYDOWN:
            
    if event.key == pygame.K_UP:  
        posJ.move_ip(0, -10)

    # etc.
# ...

Edit : pas besoin des parenthèses non plus

Zeste de Savoir, le site qui en a dans le citron !

realmagma

2 août 2010 à 11:06:03

Bonjour tout le monde,

grâce à vous mon code marche à la perfection :-°

. J'ai décidé d'implémenter mon code avec des classes simplifiées, comme je le ferais dans mon bomberman.

Mais voilà, mon code bug au niveau du blit, effacement de l'ecran contenu dans une méthode de ma classe Perso.

J'obtiens l'erreur suivante, ne sachant pourquoi:

File "C:\Users\utilisateur\Documents\Logiciels\Python\fichier\essaiClasse.py
line 79, in menage
  screen.fill((255, 255, 255), self.rectangle)
atributeError: 'Perso' object has no attribute 'rectangle'

Je vous post mon code:

################################
## Les Modules Importés:  (3) ##
#
import pygame, os
from pygame.locals import *


################################
## Les classes & fonctions:   ##
#
class Perso(object):
    """
    Charge les images
    Fait bouger le perso
    Blit, rafraichit l'ecran/perso
    """
    def __ini__(self):
        """
        Charge les images ainsi
        que les données nécessaires
        """
        self.name = "Pseudo_1"

        self.chemin = os.path.join("C:", "Documents\\Logiciels\\Python\\fichier\\gui\\")
        self.monImageB = pygame.image.load(chemin + "teteB.PNG") #Tete bas
        self.monImageH = pygame.image.load(chemin + "teteH.PNG") #Tete haut
        self.monImageG = pygame.image.load(chemin + "teteG.PNG") #Tete Gauche
        self.monImageD = pygame.image.load(chemin + "teteD.PNG") #Tete Droite

        #On cree un rect, pour retenir la pos
        self.imageAct  = self.monImageB
        self.rectangle = self.imageAct.get_rect()
        self.rectangle.topleft(60, 60)
    
    #
    ##Les methodes
    #
    def bouge(self):
        """
        Permet de faire bouger
        le joueur dans la
        direction voulue
        """
        for event in pygame.event.get():
            if(event.type is pygame.KEYDOWN):
                                                    ########################
                if event.key == pygame.K_UP:        #Ne pas oublier        #
                    self.imageAct = self.monImageH  #de changer imageAct   #
                    self.move_ip(0, -10)            #pour que la bonne tête#
                                                    #soit blité            #
                elif event.key == pygame.K_DOWN:    ########################
                    self.imageAct = self.monImageB  
                    self.move_ip(0, 10)             

                elif event.key == pygame.K_RIGHT:   
                    self.imageAct = self.monImageD  
                    self.move_ip(10, 0)             

                elif event.key == pygame.K_LEFT:    
                    self.imageAct = self.monImageG  
                    self.move_ip(-10, 0)            

                
    def menage(self):
        """
        Remplie le rect d'une couleur
        Blit le perso
        Met à jour l'ecran
        """
        screen.fill((255, 255, 255), self.rectangle)
        screen.blit(self.imageAct, self.rectangle)
        pygame.display.flip()
                 
        
################################
## Les diférrentes variables: ##
#
continuer = True


################################
## Programme Principale:      ##
#
pygame.init()

#Une surface pour l'ecran
screen = pygame.display.set_mode((200, 200))
pygame.display.set_caption("boum")
screen.fill((255, 255, 255)) #En blanc c'est jolie
pygame.display.flip()

#joueur est du type Perso()
joueur = Perso()

while(continuer):
    for event in pygame.event.get():
        if event.type is pygame.QUIT:
            continuer = False
            
        elif(event.type is pygame.KEYDOWN):  
            joueur.bouge()
            joueur.menage()

P.S: Puis-je bliter comme je le fais dans ma fonction; mon 'rect' issu d'une classe dans ma mainBoucle?

Je vous remercie d'avance pour vos futurs explications.

Anonyme

2 août 2010 à 12:04:04

As-tu créer une surface arrière plan?

background = pygame.Surface(screen.get_size())

realmagma

2 août 2010 à 12:17:11

Citation : fred1599

As-tu créer une surface arrière plan?
background = pygame.Surface(screen.get_size())

Non, je n'en n'ai pas crée. Pourquoi dont ?

Anonyme

2 août 2010 à 12:22:46

Parce-que selon la doc (je connais pas trop pygame) la méthode fill et la méthode blit on besoin de la classe surface.

http://www.pygame.org/docs/ref/surface.html

Enfin je dis ça je dis rien :euh:

nohar

2 août 2010 à 13:09:52

Ton constructeur s'appelle __ini__ au lieu de __init__, ce qui empêche l'objet de s'initialiser correctement...

Ensuite dans les méthodes où tu appelles screen.blit( ... ) , screen n'est pas référencée. Tu as bien la surface screen à la fin de ton code, mais étant donné que tu ne la passe pas en argument à ces fonctions, elles ne peuvent pas savoir de quoi il s'agit.

Zeste de Savoir, le site qui en a dans le citron !

realmagma

2 août 2010 à 15:51:34

Décidement, les classes et moi ça fait au moins trois :-°

.

J'ai changé la ligne 33 avec la variable 'chemin'. J'ai juste enlevé 'self.' devant car ça ne voulait pas interpréter.Ensuite j'ai dû enlever

self.rectangle.topleft(60, 60)

pour la même chose précédante. (Je l'ai donc mit en commentaire)
J'ai rajouté 'screen' dans le constructeur et la méthode menage

def __init__(self, screen):
def menage(self, screen):

Ce qui donne lors de l'instantation:

joueur = Perso(screen)

Et lors de l'appel de la méthode dans ma mainLoop:

joueur.menage(screen)

Ce qui ne va pas: Il ne reconnaît pas self.rectangle.topleft(60, 60)

self.rectangle.topleft(60, 60)
Error: 'tuple' object is not callable

Admettons que je l'enlève, la tête bas se blit puis plus rien. o_O

Rien ne bouge/se blit/ comme si je n'appelais pas ma methode 'menage(screen)'

Il faut vrément que j'y arrive, la notion de POO est très abstraite. C'est avec des exemples que je comprends le mieux, notamment à celui-ci, réutilisant les classes et Pygame.

################################
## Les Modules Importés:  (3) ##
#
import pygame, os
from pygame.locals import *


################################
## Les classes & fonctions:   ##
#
class Perso(object):
    """
    Charge les images
    Fait bouger le perso
    Blit, rafraichit l'ecran/perso
    """
    def __init__(self, screen):
        """
        Charge les images ainsi
        que les données nécessaires
        """
        self.name = "Pseudo_1"

        self.chemin = os.path.join("C:", "Documents\\Logiciels\\Python\\fichier\\gui\\") #Cette partie est corrigée
        self.monImageB = pygame.image.load(self.chemin + "teteB.PNG") #Tete bas
        self.monImageH = pygame.image.load(self.chemin + "teteH.PNG") #Tete haut
        self.monImageG = pygame.image.load(self.chemin + "teteG.PNG") #Tete Gauche
        self.monImageD = pygame.image.load(self.chemin + "teteD.PNG") #Tete Droite

        #On cree un rect, pour retenir la pos
        self.imageAct  = self.monImageB
        self.rectangle = self.imageAct.get_rect()
        #self.rectangle.topleft(60, 60) ICI PROBLEME
    
    #
    ##Les methodes
    #
    def bouge(self):
        """
        Permet de faire bouger
        le joueur dans la
        direction voulue
        """
        for event in pygame.event.get():
            if(event.type is pygame.KEYDOWN):
                                                    ########################
                if event.key == pygame.K_UP:        #Ne pas oublier        #
                    self.imageAct = self.monImageH  #de changer imageAct   #
                    self.move_ip(0, -10)            #pour que la bonne tête#
                                                    #soit blité            #
                elif event.key == pygame.K_DOWN:    ########################
                    self.imageAct = self.monImageB  
                    self.move_ip(0, 10)             

                elif event.key == pygame.K_RIGHT:   
                    self.imageAct = self.monImageD  
                    self.move_ip(10, 0)             

                elif event.key == pygame.K_LEFT:    
                    self.imageAct = self.monImageG  
                    self.move_ip(-10, 0)                 

                
    def menage(self, screen):
        """
        Remplie le rect d'une couleur
        Blit le perso
        Met à jour l'ecran
        """
        screen.blit(self.imageAct, self.rectangle)
        pygame.display.flip()
        screen.fill((255, 255, 255), self.rectangle)
                 
        
################################
## Les diférrentes variables: ##
#
continuer = True


################################
## Programme Principale:      ##
#
pygame.init()

#Une surface pour l'ecran
screen = pygame.display.set_mode((200, 200))
pygame.display.set_caption("boum")
screen.fill((255, 255, 255)) #En blanc c'est jolie
pygame.display.flip()

#joueur est du type Perso()
joueur = Perso(screen)

while(continuer):
    for event in pygame.event.get():
        if event.type is pygame.QUIT:
            continuer = False
            
        elif(event.type is pygame.KEYDOWN):  
            joueur.bouge()
            joueur.menage(screen)

Je remercie encore une fois ceux qui m'aideront à trouver ce qui ne vas pas et ceux qui donnent des conseils.

EDIT: Pour ce que j'ai dit sur le chemin, c'est corrigé. Il fallait mettre 'self.' devant tout les 'chemins'

nohar

2 août 2010 à 16:09:22

Citation : realmagma

J'ai rajouté 'screen' dans le constructeur et la méthode menage
def __init__(self, screen):
def menage(self, screen):

Vu ton code, tu n'as pas besoin de passer la surface screen à ton constructeur (puisque tu ne l'utilises pas dedans).

Citation : realmagma

Ce qui ne va pas: Il ne reconnaît pas self.rectangle.topleft(60, 60)
self.rectangle.topleft(60, 60)
Error: 'tuple' object is not callable

Normal, topleft est un tuple, pas une méthode :

self.rectangle.topleft = (60, 60)

Enfin, à quoi correspond la méthode self.move_ip(...) dans ta méthode "bouger" ? Je ne la vois pas dans la déclaration de ton personnage...

Tu devrais la remplacer par des appels à la méthode self.rectangle.move_ip(...) qui, elle, existe.

Zeste de Savoir, le site qui en a dans le citron !

realmagma

2 août 2010 à 17:06:07

Bien vu, comme quoi l'oeil d'un expert est plus performant que celui d'un novice comme moi

.

C'est ok pour le topleft, j'ai enlevé le 'screen' dans mon constructeur __init__ .

De plus, dans ma méthode 'bouger' j'ai enlevé la boucle for et tout marche à merveille.

Je vous remercie tous, et je vous tiens au courant pour le bomberman ou si j'ai problème dans pygame ou avec les classes.

Merci.

EDIT: Est-ce normal que mon programme prend 50% de mon CPU ?

################################
## Les Modules Importés:  (3) ##
#
import pygame, os
from pygame.locals import *


################################
## Les classes & fonctions:   ##
#
class Perso(object):
    """
    Charge les images
    Fait bouger le perso
    Blit, rafraichit l'ecran/perso
    """
    def __init__(self):
        """
        Charge les images ainsi
        que les données nécessaires
        """
        self.name = "Pseudo_1"
        
        self.chemin = os.path.join("C:", "Documents\\Logiciels\\Python\\fichier\\gui\\")
        self.monImageB = pygame.image.load(self.chemin + "teteB.PNG") #Tete bas
        self.monImageH = pygame.image.load(self.chemin + "teteH.PNG") #Tete haut
        self.monImageG = pygame.image.load(self.chemin + "teteG.PNG") #Tete Gauche
        self.monImageD = pygame.image.load(self.chemin + "teteD.PNG") #Tete Droite

        #On cree un rect, pour retenir la pos
        self.imageAct  = self.monImageB
        self.rectangle = self.imageAct.get_rect()
        self.rectangle.topleft = (60, 60) 
    
    #
    ##Les methodes
    #
    def bouge(self):
        """
        Permet de faire bouger
        le joueur dans la
        direction voulue
        """
        
        if(event.type is pygame.KEYDOWN):
                                                    ########################
            if event.key == pygame.K_UP:            #Ne pas oublier        #
                    self.imageAct = self.monImageH  #de changer imageAct   #
                    self.rectangle.move_ip(0, -10)  #pour que la bonne tête#
                                                    #soit blité            #
            elif event.key == pygame.K_DOWN:        ########################
                    self.imageAct = self.monImageB  
                    self.rectangle.move_ip(0, 10)             

            elif event.key == pygame.K_RIGHT:   
                    self.imageAct = self.monImageD  
                    self.rectangle.move_ip(10, 0)             

            elif event.key == pygame.K_LEFT:    
                    self.imageAct = self.monImageG  
                    self.rectangle.move_ip(-10, 0)                 

                
    def menage(self, screen):
        """
        Remplie le rect d'une couleur
        Blit le perso
        Met à jour l'ecran
        """
        screen.blit(self.imageAct, self.rectangle)
        pygame.display.flip()
        screen.fill((255, 255, 255), self.rectangle)
                 
        
################################
## Les diférrentes variables: ##
#
continuer = True


################################
## Programme Principale:      ##
#
pygame.init()

#Une surface pour l'ecran
screen = pygame.display.set_mode((200, 200))
pygame.display.set_caption("boum")
screen.fill((255, 255, 255)) #En blanc c'est jolie
pygame.display.flip()

#joueur est du type Perso()
joueur = Perso()

while(continuer):
    for event in pygame.event.get():
        if event.type is pygame.QUIT:
            continuer = False
            
        elif(event.type is pygame.KEYDOWN):  
            joueur.bouge()
            joueur.menage(screen)

nohar

2 août 2010 à 17:14:44

Citation : realmagma

EDIT: Est-ce normal que mon programme prend 50% de mon CPU ?

Oui, parce que tu ne limites pas le framerate.

Pour ça, dans la fonction principale, initialise une horloge :

horloge = pygame.time.Clock()

Puis dans la boucle, utilise-la pour limiter l'affichage à 20 ou 30 FPS:

horloge.tick(20)

Ton programme devrait bouffer beaucoup moins de CPU tout d'un coup.

Zeste de Savoir, le site qui en a dans le citron !

realmagma

2 août 2010 à 17:29:18

En effet, mon programme tourne à 0% voir 1% maintenant

realmagma

10 août 2010 à 11:24:52

Bonjour à tous les zéros,

J'ai un petit problème au niveau de mon bomberman. J'ai décidé de regrouper les coordonnées de chaques bombes posées dans une liste, que je passe en paramètre à une méthode. Le problème c'est que ma liste est reconnue comme un <NoneType> et non comme <list>. Je ne sais pas pourquoi ça ne veut pas fonctionner.

Pourriez-vous m'aider s'il vous plaît.

(Je vous donne que des portions de codes)

Fichier 1: bomberMain2.py (Ma liste à été déclarée auparavant)

while(continuer):
    horloge.tick(20) #Pour consommer moin de CPU
    
    for event in pygame.event.get():
        
        if event.type is pygame.QUIT:
            continuer = False
            
        elif(event.type is pygame.KEYDOWN):  
            joueur.bouge(event, hauteurEcran, largeurEcran)
            joueur.menage(screen)
            listeBombe = joueur.poserBombe(event, listeBombe)

Fichier 2: bomberClasse2.py (Une méthode de ma classe Perso() )

def poserBombe(self, event, listeBombe):
        """
        Permet de poser une
        bombe sans blit
        """
        if event.type is pygame.KEYDOWN:
            if event.key is pygame.K_SPACE:
                self.rectBombe.x = self.rectPerso.x
                self.rectBombe.y = self.rectPerso.y

                li = []
                li.append((self.rectBombe.x, self.rectBombe.y))
                listeBombe.extend(li)
                print(type(li), type(listeBombe)) #Essai pour voir ce qui cloche
                return listeBombe

Tout marche très bien (pour le moment) sauf ça. Mon personnage bouge dans les 4 directions, blit les bombes (Le problème c'est qu'il faut créer une surface par bombe; n'ayant pas compris l'héritage d'après le tutoriel de Swinnen je rame un peu :-°

)

Une idée pour les listes ?
Je vous remercie d'avance.

EDIT: En faite, à chaque fois que j'appuie sur ESPACE ma bombe se blit sur les coordonnées de mon personnage. J'aimerais récupérer ses coordonées dans une listes pour gérer les explosions, pour savoir combien il reste de bombes qui n'ont pas explosées, supprimer des coordonnées une fois explosées ETC

weyzohorth

10 août 2010 à 21:05:02

Bonsoir,

Pour les listes vérifies que ta fonction joueur.poserBombe() te retourne toujours une liste. Si tu as des blocs if vérifies que tu as un return par défaut.

Sinon à mon avis faire une liste pour stocker les coordonnées des bombes est une mauvaise idée. Mieux vaut faire une liste d'instancse de classe Bombe et travailler avec l'instance elle-même plutôt que de séparer les coordonnées dans une liste à part. C'est beaucoup plus simple à manipuler.

Bonne soirée.

realmagma

11 août 2010 à 10:54:17

Merci W3YZOH0RTH pour ta réponse,

J'ai crée ma liste dans le constructeur (__init__) de ma classe <Perso> en attendant.
Pour poursuivre mon bomberman, j'ai dû me renseigner sur l'héritage et cie. J'ai regardé le tutorield e Swinnen mais je n'ai pas encore tout compris.

Voici deux classes: Perso et Bombe:
J'aimerais accéder à un attribut dans mon constructeur de la classe Perso (ici c'est:

self.listeB = [(10, 20), (30, 40)...]

Mais comment faire ?
J'ai essayé ceci ainsi que plusieurs choses.

Classe Perso(): (Ce 'est pas celle de mon Bomberman, c'est juste un exemple)

class Perso():
	def __init__(self):
		self.name = "Pseudo"
		self.position = (68, 90)
		self.listeB = [(10, 20), (30, 40), (40, 50)]
	def g_name(self):
		self.name = name
		return name
	def s_name(self, newName):
		self.name = self.newName

Classe Bombe(Perso):

class Bombe(Perso):
	def __init__(self, Perso.listeB):
		self.nom = "bombe1"
	def g_liste(self, listeB):
		return self.listeB

J'ai tout essayé en enlevant des self, mon 'Perso.' dans le init etc mais sans succès.

Quelqu'un pourrait me faire un petit topo sur l'heritage Simple et le polymorphisme en attendant un/plusieurs nouveau(x) chapitre(s) d'un des deux tutoriels?
Je vous remercie d'avance.

P.S: J'utilise Python 3

Anonyme

11 août 2010 à 11:25:04

Rien de tel qu'un exemple

>>> class A():
        def __init__(self):
                self.name="fred"

        
>>> class B(A):
        def __init__(self):
                A.__init__(self)

                
>>> test=B()
>>> dir(test)
['__doc__', '__init__', '__module__', 'name']
>>> test.name
'fred'
>>>

Autre exemple plus concret

>>> class Rectangle():
        def __init__(self, largeur, longueur):
                self.largeur=int(largeur)
                self.longueur=int(longueur)
        def get_attribute(self):
                return (self.largeur, self.longueur)
        def aire(self):
                return self.longueur*self.largeur

        
>>> class Carre(Rectangle):
        def __init__(self, cote):
                Rectangle.__init__(self, cote, cote)

                
>>> R=Rectangle(12, 5)
>>> R.aire()
60
>>> C=Carre(15)
>>> C.aire()
225
>>> R.get_attribute()
(12, 5)
>>> C.get_attribute()
(15, 15)
>>>

realmagma

11 août 2010 à 11:52:35

Merci Fred pour ses explications

.

Admettons maintenant qu'il y ait plein plein d'attributs dans mon constructeur de ma classe <Perso> et que je n'en veuille qu'un seul que je peux voir/modifier depuis ma classe <Bombe> (encore une fois, ma 'listeB'

)

Ma question: Il y a t'il une astuce pour ne pouvoir voir/modifier qu'un seul attribut de ma classe <Perso> à partir de <Bombe>, sans que les autres soient accessible (dans ma classe <Bombe>)?

Anonyme

11 août 2010 à 12:02:39

Je ne crois pas que se soit possible, lorsque tu hérites d'une classe, c'est tous les attributs et méthodes de la classe dont tu hérites.

Maintenant je peux me tromper, mais c'est difficilement faisable à mon avis.

Qui puis-est je ne vois pas trop l'intérêt, si tu peux m'expliquer pourquoi tu ne veux pas que ta classe ai accès aux attributs de la classe héritée. o_O

realmagma

11 août 2010 à 12:25:26

Je vais dévoiler mon code qui, j'espère vous fera tous comprendre pourquoi je fais ça

.

Avant tout, il faut que vous sachiez que mon code ne contient pas d'erreurs, je veux dire par là qu'il compile, mon personnage se déplace à D. G. H. B., pose une bombe, ne sort pas de l'écran.

J'ai deux classes comme vous le savez déjà: <Perso(object)> et <Bombe(Perso)>.
Je n'arrivais pas à faire en sorte que la classes <Bombe> communique avec la classe <Perso>.

- Pourquoi les faire communiquer ?
=>Tout simplement car il y a quelque chose que mon programme ne fait pas.

Quand j'appuie sur ESPACE une bombe se blite à l'écran sous la position du joueur. Lorsque j'en blit une, mon personnage ne peut pas franchir la bombe grâce à un système de collision que j'ai mit en place.

Si je blit une deuxième bombe, la première de tout à l'heure n'a plus de 'rect' (plus de position definie), or mon perso n'entre plus en collision avec celle-ci, donc quand je passe dessus la bombe, 'il l'a mange' et elle disparaît

.
(La dernière bombe blité possède le même 'rect' que la bombe n-1 mais à une position diférente)

Ce que je voulais faire:
-Charger les images de mes bombes dans la classes bombes.
-Bliter uniquement mes bombe à partir de la classe bombe(est-ce une bonne idée?)
-Retenir les coordonées de chaques bombes posées, pour leurs attribuer un 'rect' à chacunes (Comme ça, elles seront toutes infranchissables) Je ne sais pas encore comment faire, mais j'y réfléchie.

Ne prennez pas peur pour mon Code:
Deux fichiers:

bomberMain2.py: C'est mon main
bomberClasse2.py: Contient toutes mes classes:

Dans ma classe <Perso>, dans mon constructeur je:
- Charge les images nécessaires
- Leur enlèle leur contour blanc
- Leur enttribut un 'rect' (donc une position X et Y)
- Crée une liste qui retient la position de mes bombes lorsque j'appuie sur ESPACE

Dans ma classe <Bombe>: Pour l'instant elle ne sert à rien, mais grâce à l'héritage je vais soulager ma classe <Perso>

bomberMain2.py

################################
## Les Modules Importés:  (3) ##
#
import pygame, os
from pygame.locals import *
from bomberClasse2 import *

                        
################################
## Les diférrentes variables: ##
#
continuer = True
hauteurEcran, largeurEcran = 200, 200

#Pour limiter le 'fps' dans la mainLoop
horloge = pygame.time.Clock()

#Instantation
joueur = Perso()


################################
## Programme Principale:      ##
#
pygame.init()

#Une surface pour l'ecran
screen = pygame.display.set_mode((largeurEcran, hauteurEcran))
pygame.display.set_caption("Acka Boum-Boum")

screen.fill((255, 255, 255))
joueur.menage(screen)


while(continuer):
    horloge.tick(20) #Pour consommer moin de CPU
    
    for event in pygame.event.get():
        
        if event.type is pygame.QUIT:
            continuer = False
            
        elif(event.type is pygame.KEYDOWN):  
            joueur.bouge(event, hauteurEcran, largeurEcran)
            joueur.menage(screen)
            joueur.poserBombe(event)

bomberClasse2.py

################################
## Les Modules Importés:  (3) ##
#
import pygame, os
from pygame.locals import *


################################
## Les classes & fonctions:   ##
#
class Perso():
    """
    - Charge les images du perso + bombes
    - Fait bouger le perso
    - Pose une bombe de coordonnée du perso
    - Blit, rafraichit l'ecran/perso
    """
    def __init__(self):
        """
        - Charge les images ainsi
          que les données nécessaires
        """
        self.name = "Pseudo_1"
        
        self.chemin = os.path.join("C:", "Documents\\Logiciels\\Python\\fichier\\imageBomberman\\")
        self.monImageB = pygame.image.load(self.chemin + "teteBBleu.PNG") #Tete bas
        self.monImageH = pygame.image.load(self.chemin + "teteHBleu.PNG") #Tete haut
        self.monImageG = pygame.image.load(self.chemin + "teteGBleu.PNG") #Tete Gauche
        self.monImageD = pygame.image.load(self.chemin + "teteDBleu.PNG") #Tete Droite

        self.gBombe = pygame.image.load(self.chemin + "bombe2Bleu.PNG")   #Grosse bombe
        self.pBombe = pygame.image.load(self.chemin + "bombeBleu.PNG")    #Petite bombe

        #On enlève les contours blancs des images
        self.monImageB.set_colorkey((255, 255, 255))
        self.monImageH.set_colorkey((255, 255, 255))
        self.monImageG.set_colorkey((255, 255, 255))
        self.monImageD.set_colorkey((255, 255, 255))

        self.gBombe.set_colorkey((255, 255, 255))
        self.pBombe.set_colorkey((255, 255, 255))
        
        #On cree un rect, pour retenir la pos du perso
        self.persoAct  = self.monImageB
        self.rectPerso = self.persoAct.get_rect()
        self.rectPerso.topleft = (60, 60)

        #On cree un rect, pour retenir la pos de la bombe
        self.bombeAct  = self.gBombe
        self.rectBombe = self.bombeAct.get_rect()
        self.rectBombe.topleft = (40, 40)

        #Essai pour la liste de coordonée des bombes
        self.maListe = [(self.rectBombe.x, self.rectBombe.y)]
        
    #
    ##Les methodes
    #
    def bouge(self, event, hauteurEcran, largeurEcran):
        """
        - Permet de faire bouger
          le joueur dans la
          direction voulue
        - Colision si le perso dépasse l'écran:
            .On sais que le perso avance de 10 en 10 pixels
            .On fait en sorte qu'il ne depasse pas la carte
            .(-30 ou +10 car les bords font partie de 'screen' donc
             si on ne le fait pas, le joueur va rentrer en collision
             avec l'écran que 30 ou 10 pixels de moins/plus, on le verra
             donc qu'a moitier si on ne le fait pas)
        """
        #Ne pas oublier de mettre à jour imageAct pour
        #bliter la bonne tête
        # On teste les collisions même avec les coins,
        # pour éviter que le perso ne passe à travers,
        # d'où les self.rectBombe.x +/- un nombre
        # d'où les self.rectBombe.y +/- un nombre
        if event.type is pygame.KEYDOWN:
            if event.key == pygame.K_UP and self.rectPerso.y >= 10:
                if self.rectPerso.collidepoint(self.rectBombe.x, self.rectBombe.y+20) or self.rectPerso.collidepoint(self.rectBombe.x+10, self.rectBombe.y+20):  #Collision avec un rectBombeB            
                    self.persoAct = self.monImageH
                else:
                    self.persoAct = self.monImageH      
                    self.rectPerso.move_ip(0, -10)

                    
            elif event.key == pygame.K_DOWN and self.rectPerso.y <= hauteurEcran-30:
                if self.rectPerso.collidepoint(self.rectBombe.x, self.rectBombe.y-10) or self.rectPerso.collidepoint(self.rectBombe.x+10, self.rectBombe.y-10):  #Collision avec un rectBombeH
                    self.persoAct = self.monImageB
                else:    
                    self.persoAct = self.monImageB  
                    self.rectPerso.move_ip(0, 10)             


            elif event.key == pygame.K_RIGHT and self.rectPerso.x <= largeurEcran-30:               
                if self.rectPerso.collidepoint(self.rectBombe.x-10, self.rectBombe.y) or self.rectPerso.collidepoint(self.rectBombe.x-10, self.rectBombe.y+10):  #Collision avec un rectBombeG
                    self.persoAct = self.monImageD
                else:    
                    self.persoAct = self.monImageD  
                    self.rectPerso.move_ip(10, 0)             


            elif event.key == pygame.K_LEFT and self.rectPerso.x >= 10:              
                if self.rectPerso.collidepoint(self.rectBombe.x+20, self.rectBombe.y) or self.rectPerso.collidepoint(self.rectBombe.x+20, self.rectBombe.y+10):  #Collision avec un rectBombeD
                    self.persoAct = self.monImageG
                else:    
                    self.persoAct = self.monImageG  
                    self.rectPerso.move_ip(-10, 0)

                
    def menage(self, screen):
        """
        - Remplie le rect d'une couleur
        - Blit le perso
        - Met à jour l'ecran
        """
        screen.blit(self.persoAct, self.rectPerso)
        screen.blit(self.bombeAct, self.rectBombe) #Essai pour bliter la bombe
        pygame.display.flip()
        screen.fill((255, 255, 255), self.rectPerso)


    def poserBombe(self, event):
        """
        Permet de poser une
        bombe sans blit
        """
        if event.type is pygame.KEYDOWN:
            if event.key is pygame.K_SPACE:
                self.rectBombe.x = self.rectPerso.x
                self.rectBombe.y = self.rectPerso.y

                self.maListe.append((self.rectBombe.x, self.rectBombe.y))
                print(self.maListe)



class Bombe(Perso):
    """
    - Charge les images
    - Blit les bombes
    - Blit les explosions
    - Gère les explosions ainsi que
      ses colisions
    - Rafraîchit/efface l'écran
    """
    def __init__(self):
        """
        Charge les images des bombes
        ainsi que les données nécessaires
        """
        #On veut heriter de quelque donées de la classe <Perso>
        Perso.__init__(self)

        #Ou sont les images
        self.chemin = os.path.join("C:", "Documents\\Logiciels\\Python\\fichier\\imageBomberman\\")
        self.gBombe = pygame.image.load(self.chemin + "bombe2Bleu.PNG")
        self.pBombe = pygame.image.load(self.chemin + "bombeBleu.PNG")

        self.gBombe.set_colorkey((255, 255, 255))#
        self.pBombe.set_colorkey((255, 255, 255))#

        #On créer un rect pour récupérer les coordonnées
        self.bombeAct = self.gBombe
        self.rectBombe = self.bombeAct.get_rect()
        self.rectBombe.topleft = (40, 40)

        
    def menageBombe(self, screen, event):
        """
        - Remplie le rect d'une couleur
        - Blit le perso
        - Met à jour l'ecran
        """           
        if event.type is pygame.KEYDOWN:
            if event.key is pygame.K_SPACE:
                screen.blit(self.bombeAct, self.rectBombe)
                pygame.display.flip()
                screen.fill((255, 255, 255), self.rectBombe)
                
                
    
if __name__ == "__main__":
    Perso()
    Bombe()

Voilà je crois que j'ai tout dit

Holt

11 août 2010 à 12:55:16

Je vais répondre à la question de ton post d'avant car c'est possible de faire ce que tu veux faire (n'avoir accès qu'à un nombre limité d'attribut de la classe Perso dans la classe bombe), mais à mon avis tu devrais créer une classe plus générale et la dériver pour obtenir 'Perso' et 'Bombe' (si tu as besoin de cacher autant d'attribut de la classe mère à la classe fille, c'est que ton héritage n'était pas forcément logique à mon avis).

Sinon pour faire ce que tu veux faire tu peux utiliser les méthodes spéciales __getattribute__, __getattr__, __setattr__ (même si c'est assez lourd à mettre en place), ou les propriétés peut être (mais NoHaR t'en parleras mieux que moi

http://mikael-capelle.fr/

realmagma

11 août 2010 à 13:09:42

Citation : Holt

... mais à mon avis tu devrais créer une classe plus générale et la dériver pour obtenir 'Perso' et 'Bombe' (si tu as besoin de cacher autant d'attribut de la classe mère à la classe fille, c'est que ton héritage n'était pas forcément logique à mon avis).

En faite tu veux dire une classe Mère où mes classes <Perso> et <Bombe> sont leur fille.
Donc dans cette classe Mère, je pourrais charger les images, enlever leur contour blanc, créer un 'rect' pour le personnage.
Pas bête, je n'y avais pas pensé.

Devrais-je mettre seulement ça dans cette classe, ou bien autre chose pour pourvoir alléger les classes filles ?

Encore merci

Holt

11 août 2010 à 13:11:29

C'est à toi de voir, tu peux déjà voir ce qui est en commun avec les classes Persos et Bombes et le mettre dans une classe mère, tu auras ainsi l'avantage de pouvoir toucher à ta classe Perso comme tu le souhaite sans affecter la classe Bombe

http://mikael-capelle.fr/

<< 1 2 3 >>

Bomberman

× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.

× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.

Bomberman

Prologue

Bomberman

Supprimer

Modérer

Signaler le message aux modérateurs