Bonjour bonjour communauté d'OpenClassroom,

En classe de Terminale S, nous avons comme projet d'ISN de créer un jeu 2D avec Pygame, j'ai lu l'ensemble des cours Pygame mais je suis confronté à un problème, j'aimerais gérer le saut d'un personnage, ainsi que les déplacements avec une animation GIF.

Le projet n'étant qu'à son commencement, le code est court et peu complexe pour le moment, je n'ai écrit que du code que je comprends !

Merci d'avance de votre aide !!!

Mon code :

"""
Jeu
"""
import pygame

pygame.init()

fenetre = pygame.display.set_mode ((720,480))
icone = pygame.image.load('icone.png')
pygame.display.set_caption('Agent 69')


continuer = 1
while continuer:
    accueil = pygame.image.load('accueil.jpg').convert()
    fenetre.blit(accueil, (0,0))
	
    pygame.display.flip()
	
    continuer_jeu = 1
    continuer_accueil = 1
	
	pygame.ket.set_repeat(0,0)
	
    while continuer_accueil:
		
        pygame.time.Clock().tick(60)
		
        for event in pygame.event.get():
            if event.type == QUIT or event.type == KEYDOWN and event.key == K_ESCAPE :
                continuer_accueil = 0
                continuer_jeu = 0
                continuer = 0
                choix = 0
				
            elif event.type == KEYDOWN:
                if event.key == K_RETURN:
                    continuer_accueil = 0
                    choix = 'n1'
    
    if choix != 0:
        fond = pygame.image.load('etoilen1.png').convert()
        perso = pygame.image.load('agent.gif').convert_alpha()
		position_perso = perso.get_rect()
		fenetre.blit(perso, position_perso)
        
        while continuer_jeu:
            
            pygame.time.Clock().tick(60)
            
            for event in pygame.event.get():
                
                if event.type == QUIT:
                    continuer_jeu = 0
                    continuer = 0
                
                elif event.type == KEYDOWN:
                    if event.key == K_ESCAPE:
                        continuer_jeu = 0
                
                    elif event.key == K_RIGHT:
                        position_perso = position_perso.move(1,0)
                    elif event.key == K_LEFT:
                        position_perso = position_perso.move(-1,0)
            
            fenetre.blit(fond, (0,0))
            niveau.afficher(fenetre)
            fenetre.blit(perso, position_perso)
            
            pygame.display.flip()
 

comme je l'ai déjà dis dans le sujet suivant https://openclassrooms.com/forum/sujet/pourquoi-mon-code-ne-fonctionne-pas , faire des classes facilite tout. 

Pour les animations j'en ai jamais fais de trop complexe mais ma méthode était plutôt d'utiliser un sprite set (exemple  ) a partir du quel on affiche qu'une partie de l'image avec des subsurface et on parcourt toute l'image comme ça (une vidéo basique mais qui m'as bien servi: https://www.youtube.com/watch?v=f1yU9edRNb8 )

Merci beaucoup de ta réponse, je vais donc m'orienter vers des classes et suivre ton exemple !

Toutefois, je ne sais toujours pas comment créer du coup un saut :/

Je vais améliorer mon code à l'aide d'une classe et ensuite revenir vers vous pour améliorer le tout !!!

A très vite

Après modification, je reviens vers vous pour savoir si tout est opérationnel au niveau de la gestion de personnage, je ne peux pas essayer tant que je n'ai pas de niveau en main  mais surtout, le seul appareil sous python que je possède actuellement est l'ordinateur de mon établissement, je dois donc avancer mon code toute la semaine et ne peux le tester qu'un jour par semaine...

Bref ! Voilà mon nouveau code :

"""
Jeu Agent69
"""
import pygame

from pygame.locals import *

pygame.init()

fenetre = pygame.display.set_mode ((720,480))
icone = pygame.image.load('icone.png')
pygame.display.set_caption('Agent 69')


continuer = 1
while continuer:
    accueil = pygame.image.load('accueil.jpg').convert()
    fenetre.blit(accueil, (0,0))
	
    pygame.display.flip()
	
    continuer_jeu = 1
    continuer_accueil = 1
	
	pygame.ket.set_repeat(0,0)
	
    while continuer_accueil:
		
        pygame.time.Clock().tick(60)
		
        for event in pygame.event.get():
            if event.type == QUIT or event.type == KEYDOWN and event.key == K_ESCAPE :
                continuer_accueil = 0
                continuer_jeu = 0
                continuer = 0
                choix = 0
				
            elif event.type == KEYDOWN:
                if event.key == K_RETURN:
                    continuer_accueil = 0
                    choix = 'n1'
    
    if choix != 0:
        fond = pygame.image.load('etoilen1.png').convert()
        perso = pygame.image.load('agent.gif').convert_alpha()
		position_perso = perso.get_rect()
		fenetre.blit(perso, position_perso)
        
        while continuer_jeu:
            
            pygame.time.Clock().tick(60)
            
            for event in pygame.event.get():
                
                if event.type == QUIT:
                    continuer_jeu = 0
                    continuer = 0
                
                elif event.type == KEYDOWN:
                    if event.key == K_ESCAPE:
                        continuer_jeu = 0
                
                    elif event.key == K_RIGHT:
                        agent.deplacer('droite')
                    elif event.key == K_LEFT:
                        agent.deplacer('gauche')
                    elif event.key == K_UP:
                        agent.deplacer('haut')
            
            fenetre.blit(fond, (0,0))
            fenetre.blit(perso, position_perso)
            
            pygame.display.flip()

"""
Classes Agent 69
"""
import pygame

from pygame.locals import *

class Perso:
	def __init__(self, droite, gauche, haut, niveau):
		self.static = pygame.image.load(static).convert_alpha
		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.current = self.static

		self.rect = self.static.get_rect()
		self.speed = 10

	def get_pos(self):
		[self.rect[0],self.rect[1]]

	def move(self, events):
		for event in events:
			if event.type == KEYDOWN:
				if event.key == K_LEFT:
					self.rect.move(-self.speed,0)
					self.current = self.gauche
				elif event.key == K_RIGHT:
					self.rect.move(self.speed,0)
					self.current = self.droite
				elif event.key == K_UP:
					self.rect.move(self.speed,10)
					self.current = self.haut
			elif event.type == KEYUP:
				self.current = self.static

	def show(self,events):
		self.move(events)
		self.blit(self.current,self.get_pos())

Oui, je n'ai pas encore d'images 

-
Edité par THE RU[i]NNER 19 mars 2018 à 18:21:56

"""
Jeu Agent69
"""
import pygame
from lefichiercontenantlaclasseperso import Perso #a remplacer évidemment
from pygame.locals import *
 
pygame.init()
fenetre = pygame.display.set_mode ((720,480))

# chargement des images à l'avance pour des raisons de performances (perso ne sera pas utile je pense)
fond = pygame.image.load('etoilen1.png').convert()
perso = pygame.image.load('agent.gif').convert_alpha()
position_perso = perso.get_rect()

icone = pygame.image.load('icone.png')
pygame.display.set_caption('Agent 69')
 
 
continuer = True # je préfère True
accueil = pygame.image.load('accueil.jpg').convert() # ici c'est mieux ça evite un chargement inutile a chaque tour

# si tu défini les paramètre par défaut avant tu pourras les changer plus facilement après
pygame.key.set_repeat(30,30)
fps = 60 
control_fps = pygame.time.Clock()

agent = Perso(win) # tu as oublié de créer ton perso il faudra que tu mette les bonnes images dans les parenthèses

while continuer:
    fenetre.blit(accueil, (0,0))
    pygame.display.flip()
     
    continuer_jeu = True
    continuer_accueil = True
     
     
    while continuer_accueil:
         
        control_fps.tick(fps)
         
        for event in pygame.event.get():
            if event.type == QUIT or event.type == KEYDOWN and event.key == K_ESCAPE :
                continuer_accueil = False
                continuer_jeu = False
                continuer = False
                choix = False
                 
            elif event.type == KEYDOWN:
                if event.key == K_RETURN:
                    continuer_accueil = False
                    choix = 'n1'
     
    if choix: # != 0 est inutile a écrire
        # fenetre.blit(perso, position_perso) cette ligne est inutile c'est la classe perso qui s'occupe de tout
         
        while continuer_jeu:
             
            control_fps.tick(fps)
            events = pygame.event.get() # tu vas en avoir besoin pour que ton perso sache quoi faire
            for event in events:
                 
                if event.type == QUIT:
                    continuer_jeu = False
                    continuer = False
                 
                elif event.type == KEYDOWN:
                    if event.key == K_ESCAPE:
                        continuer_jeu = False
             
            fenetre.blit(fond, (0,0))
            agent.show(events)# cette ligne est la plus importante:
			# elle vas s'occuper seule de l'affichage et le déplacement
			# du perso comme défini dans la classe
             
            pygame.display.flip()

"""
Classes Agent 69
"""
import pygame
 
from pygame.locals import *
 
class Perso:
    def __init__(self, droite, gauche, haut, static):
        self.static = pygame.image.load(static).convert_alpha
        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.current = self.static
 
        self.rect = self.static.get_rect()
        self.speed = 10
 
    def get_pos(self):
        return [self.rect[0],self.rect[1]] # ne surtout pas oublier le return sinon c'est inutile
 
    def move(self, events):
        for event in events:
            if event.type == KEYDOWN:
                if event.key == K_LEFT:
                    self.rect.move(-self.speed,0)
                    self.current = self.gauche
                elif event.key == K_RIGHT:
                    self.rect.move(self.speed,0)
                    self.current = self.droite
                elif event.key == K_UP:
                    self.rect.move(self.speed,10) # si tu met self.speed ici il vas avancer en même temps que sauter
                    self.current = self.haut # aussi je pense que tu veux pas qu'il saute a l'infini il faudrat 
					#certainement modifier ca plus tard
            elif event.type == KEYUP:
                self.current = self.static
 
    def show(self,events):
        self.move(events)
        self.blit(self.current,self.get_pos())

Il y a certainement encore d'autre truc mais chaque chose en son temps ...

Pourquoi n'installe tu pas python chez toi ?

-
Edité par Coliculus 19 mars 2018 à 23:44:49

Merci beaucoup de toutes ces petites informations que je vais m'empresser de comprendre et de modifier dès maintenant !

Je n'installe pas tout simplement parce que je suis sur Mac et que c'est tout un parcours pour moi, un habitué de Windows, d'installer ce Python !

J'aimerais que mes sauts soient des sauts de type Mario, notre projet sera un jeu Megaman like, donc un platform shooter, donc l'objectif est que les sauts soient dynamiques (donc par exemple : appuyer sur haut, le perso saute et il peut bouger de gauche à droite durant le temps du saut en tombant) mais pour le moment je pars simplement sur : appuyer puis sauter en se déplaçant, d'où le speed et gain de hauteur (mais surement que je m'y prends mal).

Pour ce qui est du choix, nous avons prévu de faire trois niveaux, pour le moment je vais suivre ton exemple, mais par la suite je pense prendre un peu plus de liberté la dessus lorsque je maîtriserais mieux le tout, j'aime bien les True/False aussi, c'est vrai que ça rend le tout plus logique à lire !

Du coup, il y a une chose qui me chagrine, si je charge toutes mes images avant, lorsque je charge l'accueil, puis le niveau, si je ne mets pas accueil et fond, comme dans ton exemple, comment le changement d'images s'effectue ? Càd, en les chargeant avant, du coup on ne décide plus de la boucle while dans laquelle elle se charge...

-
Edité par THE RU[i]NNER 19 mars 2018 à 21:15:44

Sur mac et linux il est installé par défault il faut que tu sorte un terminal (je sais plus le nom sur mac) que tu te déplace dans le dossier avec "cd" et "ls" et que tu lance le programme en marquant "python nom_du_fichier". Pour installer pygame, je pense que faire " pip install pygame " devrait suffire, a voir ... (si pour x ou y raison t'as des problème de permissions met sudo devant tes commandes: "sudo commande")

En effet pour qu'il bouge en même temps tu t'y prend mal si tu mais un y positif c'est suffisant pour sauter après quand il sera combiné avec une autre touche ton perso bougera et sautera. Par contre pour l'instant il fait que monter il ne redescend pas, il faudra implémenter un peu de physique pour ça ...

Pour ce qui est des niveaux pareil du fais une classe qui represente un niveau et qui contient par exemple des briques qui sont des classes et ainsi de suite ... tu décompose tout ce qui est une entitée de ton jeu en classe (principe même de la POO)

Enfin, il n'y as pas de problème à changer d'image, là j'ai fais un peu vite c'est vrai mais après dans chaque boucle tu met le blit que tu veux c'est juste que tu ouvre toutes tes images avant d'aller dans les boucles ... Ce que tu avais fais avec 4-5 images ça doit marcher mais dès qu'il commence a en y avoir des dizaine ton jeu a des chance de ramer

-
Edité par Coliculus 19 mars 2018 à 22:40:09

MrGeekou a écrit:

Merci encore ! Je vais m'occuper de ma classe Niveau et de ma physique des sauts et je reviendrais vers vous pour faire un bilan du tout 

-
Edité par Coliculus 20 mars 2018 à 9:21:30

D'accord, je retiens !

Bon, après avoir fait ma classe dont je ne suis pas encore sur de son efficacité (et j'ai pu me procurer python au passage), j'ai quelques problèmes dont perso qui n'est pas défini, le win et je pense quelques erreurs par ci par là dans mes classes :/

Voici le code avec Jeu/classes/n1 :

"""
Jeu Agent69
"""
import pygame
from pygame.locals import *
from classes import *

pygame.init()

fenetre = pygame.display.set_mode ((1080,720))

fond = pygame.image.load('images/etoilen1.png').convert()
position_perso = perso.get_rect()

icone = pygame.image.load('images/icone.png').convert
pygame.display.set_caption('Agent 69')

continuer = True
accueil = pygame.image.load('images/accueil.jpg').convert()

pygame.key.set_repeat(30,30)
fps = 60
control_fps = pygame.time.Clock()

perso = Perso(win)

while continuer:
    fenetre.blit(accueil, (0,0))
    pygame.display.flip()
	
    continuer_jeu = True
    continuer_accueil = True
	
    while continuer_accueil:
        control_fps.tick(fps)
		
        for event in pygame.event.get():
            if event.type == QUIT or event.type == KEYDOWN and event.key == K_ESCAPE :
                continuer_accueil = False
                continuer_jeu = False
                continuer = False
                choix = False
				
            elif event.type == KEYDOWN:
                if event.key == K_RETURN:
                    continuer_accueil = False
                    choix = 'n1'
    
    if choix:
        
        while continuer_jeu:
            
            control_fps.tick(fps)
            events = pygame.event.get()
            
            for event in events:
                
                if event.type == QUIT:
                    continuer_jeu = False
                    continuer = False
                
                elif event.type == KEYDOWN:
                    if event.key == K_ESCAPE:
                        continuer_jeu = False

            fenetre.blit(fond, (0,0))
            agent.show(events)

            pygame.display.flip()

"""
Classes Agent 69
"""
import pygame

from pygame.locals import *

class Perso:
	def __init__(self,win):
		self.win = win
		self.static = pygame.image.load('images/static.gif').convert_alpha()
		self.droite = pygame.image.load('images/droite.gif').convert_alpha()
		self.gauche = pygame.image.load('images/gauche.gif').convert_alpha()
		self.haut = pygame.image.load('images/haut.gif').convert_alpha()

		self.current = self.static

		self.rect = self.static.get_rect()
		self.speed = 10

	def get_pos(self):
		return [self.rect[0],self.rect[1]]

	def move(self, events):
		for event in events:
			if event.type == KEYDOWN:
				if event.key == K_LEFT:
					self.rect.move(-self.speed,0)
					self.current = self.gauche
				elif event.key == K_RIGHT:
					self.rect.move(self.speed,0)
					self.current = self.droite
				elif event.key == K_UP:
					self.rect.move(self.speed,10)
					self.current = self.haut
			elif event.type == KEYUP:
				self.current = self.static

	def show(self,events):
		self.move(events)
		self.blit(self.current,self.get_pos())

class Niveau:
	def __init__(self, fichier):
		self.fichier = fichier
		self.structure = 0

	def generer(self):
		with open(self.fichier, 'r') as fichier:
			structure_niveau = []

			for ligne in fichier:
				ligne_niveau = []

				for sprite in ligne:

					if sprite != '\n':
						ligne_niveau.append(sprite)

				structure_niveau.append(ligne_niveau)
			self.structure = structure_niveau

	def afficher(self,fenetre):
		asteroid = pygame.image.load('asteroid.png').convert_alpha()
		flag = pygame.image.load('flag.png').convert_alpha()

		num_ligne = 0
		for ligne in self.structure:

			num_case = 0
			for sprite in ligne:

				x = num_case * taille_sprite
				y= num_ligne * taille_sprite
				if sprite =='a': #a = asteroid
					fenetre.blit(asteroid, (x,y))
				elif sprite == 'f':
					fenetre.blit(flag, (x,y))

				num_case += 1
			num_ligne +=1

00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000f
a00a00a00aaaa00a00aaa00aa000a000a000aaaa0000

-
Edité par THE RU[i]NNER 20 mars 2018 à 11:45:33

En fait c'est parceque win c'est la variable que toi tu appelle fenetre ni plus ni moins ( Qu'est ce que tu entend par suivre à la lettre le modèle openclassroom ? )

Pour ta fontion générer tu peux juste spliter ton niveau a "\n" c'est plus court ca remplace les lignes 49 a 60:

self.structure = fichier.read().split("\n") # t'as oublié le read aussi

asteroides et flag serait mieux en attribut de la classe Niveau comme pour la classe Perso la sinon tu refait comme avant tu charge des images à chaque tour de boucle

Pour avoir directement les numeros de ligne et de colonne tu peut écrire:

for num_ligne, ligne in enumerate(self.structure):

Maintenant tu vas avoir besoin d'image pour voir quand même ce que ca donne même si je pense qu'il y a encore des erreurs...

Bon bon xD

Alors du coup, quand je dis 'modèle open classroom', je parle des tutos Pygame qui ne sont utiles pour comprendre mais ensuite pour du 2D platform, c'est advienne que pourra !

Je n'ai pas compris pour ton premier code, je dois retirer tout ce qu'il ya sous le def generer, soit ceci :

	def generer(self):
		with open(self.fichier, 'r') as fichier:
			structure_niveau = []

			for ligne in fichier:
				ligne_niveau = []

				for sprite in ligne:

					if sprite != '\n':
						ligne_niveau.append(sprite)

				structure_niveau.append(ligne_niveau)
			self.structure = structure_niveau

et remplacer par ton code ?

Asteroids et flags ont bien été déplacé, c'est bon !

Absolument pas compris cette dernière ligne avec le 'enumerate'...

La version avec images ! (et au passage une erreur pour 'perso' non défini lorsque 'position_perso = perso.get_rect()'

"""
Jeu Agent69
"""
import pygame
from pygame.locals import *
from classes import *

pygame.init()

fenetre = pygame.display.set_mode ((1080,720))

asteroid = pygame.image.load('images/asteroid.png').convert_alpha()
flag = pygame.image.load('images/flag.png').convert_alpha()

fond = pygame.image.load('images/etoilen1.png').convert()
position_perso = perso.get_rect()

icone = pygame.image.load('images/icone.png').convert
pygame.display.set_caption('Agent 69')

continuer = True
accueil = pygame.image.load('images/accueil.jpg').convert()

pygame.key.set_repeat(30,30)
fps = 60
control_fps = pygame.time.Clock()

perso = Perso(win)

while continuer:
    fenetre.blit(accueil, (0,0))
    pygame.display.flip()
	
    continuer_jeu = True
    continuer_accueil = True
	
    while continuer_accueil:
        control_fps.tick(fps)
		
        for event in pygame.event.get():
            if event.type == QUIT or event.type == KEYDOWN and event.key == K_ESCAPE :
                continuer_accueil = False
                continuer_jeu = False
                continuer = False
                choix = False
				
            elif event.type == KEYDOWN:
                if event.key == K_RETURN:
                    continuer_accueil = False
                    choix = 'n1'
    
    if choix:
        
        while continuer_jeu:
            
            control_fps.tick(fps)
            events = pygame.event.get()
            
            for event in events:
                
                if event.type == QUIT:
                    continuer_jeu = False
                    continuer = False
                
                elif event.type == KEYDOWN:
                    if event.key == K_ESCAPE:
                        continuer_jeu = False

            fenetre.blit(fond, (0,0))
            agent.show(events)

            pygame.display.flip()

"""
Classes Agent 69
"""
import pygame

from pygame.locals import *

class Perso:
	def __init__(self,win):
		self.win = win
		self.static = pygame.image.load('images/static.gif').convert_alpha()
		self.droite = pygame.image.load('images/droite.gif').convert_alpha()
		self.gauche = pygame.image.load('images/gauche.gif').convert_alpha()
		self.haut = pygame.image.load('images/haut.gif').convert_alpha()

		self.current = self.static

		self.rect = self.static.get_rect()
		self.speed = 10

	def get_pos(self):
		return [self.rect[0],self.rect[1]]

	def move(self, events):
		for event in events:
			if event.type == KEYDOWN:
				if event.key == K_LEFT:
					self.rect.move(-self.speed,0)
					self.current = self.gauche
				elif event.key == K_RIGHT:
					self.rect.move(self.speed,0)
					self.current = self.droite
				elif event.key == K_UP:
					self.rect.move(self.speed,10)
					self.current = self.haut
			elif event.type == KEYUP:
				self.current = self.static

	def show(self,events):
		self.move(events)
		self.blit(self.current,self.get_pos())

class Niveau:
	def __init__(self, fichier):
		self.fichier = fichier
		self.structure = 0

	def generer(self):
		with open(self.fichier, 'r') as fichier:
			structure_niveau = []

			for ligne in fichier:
				ligne_niveau = []

				for sprite in ligne:

					if sprite != '\n':
						ligne_niveau.append(sprite)

				structure_niveau.append(ligne_niveau)
			self.structure = structure_niveau

	def afficher(self,fenetre):
		num_ligne = 0
		for ligne in self.structure:

			num_case = 0
			for sprite in ligne:

				x = num_case * taille_sprite
				y= num_ligne * taille_sprite
				if sprite =='a': #a = asteroid
					fenetre.blit(asteroid, (x,y))
				elif sprite == 'f':
					fenetre.blit(flag, (x,y))

				num_case += 1
			num_ligne +=1

-
Edité par THE RU[i]NNER 20 mars 2018 à 11:55:49

ca devient ça:

def generer(self): # apres pour le coup c'est pareil ca tu peux le mettre dans __init__
    with open(self.fichier, 'r') as fichier:
        structure_niveau = fichier.read().split("\n")

enumerate est une fonction qui prend en paramètre un objet itérable et qui renvoie un tuple : (nombre d'itération, valeur renvoyée). J'ai oublié mais tu doit enlever aussi les lignes 77 et 78 qui ne sont plus utiles

Pour perso c'est normal puisque il n'est défini qu'après et maintenant ce n'est plus le programme principal qui s'occupe de stocker les positions elle sont incluses dans le personnage lui-même et pour l'avoir il y a la méthode get_pos() de la classe Perso. Tu peux donc enlever cette ligne aussi

Dans classes agent 69 tu doit mettre self.win.blit a la ligne 41 pour que ca fonctionne

Enfin je te conseil d'être plus homogène, si deux fonctions de 2 classes on le même fonctionnement (show et afficher) autant les appeler pareil. De même moi j'appelle ma fenêtres win mais si pour toi c'est fenetre alors met fenetre a chaque fois

Bon bon... Il est l'heure de rendre le bilan après coup.

Tout d'abord, la partie a bien été modifié, ensuite, la partie énumérate, j'ai beaucoup trop peur de faire une bêtise, de me perdre ou quoi, et j'ai horreur de faire quelque chose que je ne comprends pas, donc pour le moment, je prends note mais ne l'instaure pas dans le code.

Chose suivante, j'ai bien retiré tout ce qui touche au perso, qui n'est du coup plus défini que par la classe.

J'ai changé le self.blit en ajoutant le fenetre, ce qui me fait venir au dernier point, du coup tu m'as eclairci dessus, je ne voyais pas trop ce que ton win signifiait mais c'est du coup ta manière à toi dans la classe d'afficher, je me retrouve avec un dernier problème pour le moment (outre le fait que ALT+F4 et echap ne veulent pas fonctionner ces touches de m**** xD), mais du coup, mon code s'achevait au depart par un agent.show(events), ou désormais, agent.afficher(events). Sauf que agent, je ne l'ai pas défini et que perso n'existe plus, donc j'affiche quoi exactement ici ?

Dis moi s'il te faut un bout de mon code ou quoi pour plus d'explications (disons que ça fait paquet de copier à maintes reprises un code !)

Une fois tous ces problèmes réglés, je m'occuperais de la classe Niveau correctement avec un peu d'aide je pense et je vais me débrouiller seul pour ce qui est de l'ajout de physique ^-^

-
Edité par THE RU[i]NNER 20 mars 2018 à 17:39:45

Pour enumerate teste des trucs tu verras c'est vraiment pas compliqué:

for index,letter in enumerate("enumerate c'est le futur"):
    print index, letter

for classement,prenom in enumerate(["bob","maurice","sylvie"]):
    print classement, prenom

Pour le perso en fait je crois que tu n'as pas compris ce que c'est qu'une classe... Micro cours: Une classe c'est un moule, c'est une manière de créer une chose. Cette chose en python on appelle ça une instance, c'est une variable du type correspondant à ta classe. Pour fabriquer cette instance qui pour le coup est ton personnage, tu vas créer une instance de la classe Perso que tu appelle comme tu veux ( c'est ce que tu fais à la ligne 28 si tu l'as pas enlevée ).

Instance = Classe(paramètres initiaux)

 Et c'est valable qu'on utilise pygame ou pas ... Ensuite ta classe défini des actions que peuvent faire ses instances, ce sont des fonction mais dans une classe on appelle ça une méthode. Une méthode s'appelle de la manière suivante:

Instance.Methode(paramètres de méthode)

Donc tu dois créer ton instance agent puis lui dire de s'afficher dans la boucle via: agent.afficher()

-
Edité par Coliculus 20 mars 2018 à 18:39:50

Bon, je vais essayer un peu des choses avec enumerate et ensuite,une fois compris, je l'ajoute à mon code ! (Je suis surtout perdu parce que ma méthode d'ajouter à chaque ligne et case me permet de voir ce qu'il se passe, là, je ne vois pas et je suis complètement perdu, je n'arrive pas à assimiler vraiment la chose mais je regarderai ca tranquillement de mon coté !)

Si j'ai bien compris, je vais créer du coup une instance qui sera par exemple : 

agent = Perso(droite, gauche, haut, events)

et ensuite le agent.afficher(events) va executer à partir de notre 'moule', agent contenant les paramètres entrés, et donc ici les evenements ! (Je croise les doigts pour bien avoir compris)

Enumerate s'occupe de faire ton compteur à ta place c'est tout

Pour les classes c'est ça à un détail près, les events on vas les mettre dans la méthode afficher parce que il vont changer à chaque tour de boucle donc à chaque tour il nous faudra les récupérer

-
Edité par Coliculus 20 mars 2018 à 19:15:33

Okay, vu sous cet angle, ça semble simple 

Oui, d'où le fait qu'on le prend plus bas, d'accord, donc dans ce cas j'ajoute ceci sans les events, et ceci, je suppose que je l'ajoute dans le programme principal (agent69) après la boucle while nous conduisant au jeu (soit après le while accueil, ça me semble logique vu que l'on ne va pas le charger avant dans l'accueil, ça me semble, pour moi, illogique, mais dans ce contexte là, j'ai du coup un message me disant que ce gauche,droite etc ne sont pas définis, j'ai soit fait une erreur dans la mise en place, soit je suis aveugle et dans ma classe j'ai fait une gaffe )

En tous les cas, tu m'as déjà énormément aidé, donc  après ceci, je pense cloturer ce sujet, jusqu'à peut etre une autre galère majeure (je n'aime pas trop solliciter quelqu'un )

Voilà voila !

-
Edité par THE RU[i]NNER 20 mars 2018 à 19:27:41

-
Edité par Coliculus 20 mars 2018 à 20:42:52

Bien le bonjour, alors, bilan après quelques jours sans nouvelles (et surtout pas mal de tests en classe du coup) !

Tout d'abord, j'ai enfin réussi à avoir un menu qui se lance puis lance la suite sans message d'erreur !

Mais, car il y a un mais, ceci ne fonctionne que lorsque je fais plusieurs choses.

Déjà, j'ai mis remis dans ma classe Niveau mes anciennes lignes de code, parce que ça ne fonctionnait pas, donc je suis retourné à mes bonnes vieilles méthodes, ensuite, les images 'asteroid' etc ne sont pas reconnu par la classe, ainsi que le 'taille_sprite' je ne comprends pas pourquoi :/

Donc, j'aimerais savoir comment faire pour que ceci fonctionne (sachant que le jeu du coup se lance sans erreur lorsque je les mets dans la classe, mais je me retrouve avec un  problème ci-après ainsi que l'erreur ci-avant)

Problème suivant, et pas des moindres, le résultat final est un fond avec mon personnage qui s'affiche en haut à gauche (ça je sais que c'est normal, c'est le sens de lecture en python et je n'ai pas de gravité et pas défini le lieu de 'spawn') mais il n'y a que ça, donc mes asteroids, drapeau et environnements (barrière) ne s'affichent pas, donc je suppose que je m'y prends mal lorsque je place mes images, ou qu'il y a un problème de lecture, ou je ne sais quoi !

Voilà ! J'espère avoir été clair dans mes mots, merci encore !

"""
Classes Agent 69
"""
import pygame
from pygame.locals import *

class Perso:
	def __init__(self,fenetre):
		self.fenetre = fenetre
		self.static = pygame.image.load('images/test.png').convert_alpha()
		self.droite = pygame.image.load('images/droite.gif').convert_alpha()
		self.gauche = pygame.image.load('images/gauche.gif').convert_alpha()
		self.haut = pygame.image.load('images/haut.gif').convert_alpha()

		self.current = self.static

		self.rect = self.static.get_rect()
		self.speed = 10

	def get_pos(self):
		return [self.rect[0],self.rect[1]]

	def move(self, events):
		for event in events:
			if event.type == KEYDOWN:
				if event.key == K_LEFT:
					self.rect.move(-self.speed,0)
					self.current = self.gauche
				elif event.key == K_RIGHT:
					self.rect.move(self.speed,0)
					self.current = self.droite
				elif event.key == K_UP:
					self.rect.move(self.speed,10)
					self.current = self.haut
			elif event.type == KEYUP:
				self.current = self.static

	def afficher(self,events):
		self.move(events)
		self.fenetre.blit(self.current,self.get_pos())
  

       
class Niveau:
	def __init__(self, fichier):
		self.fichier = fichier
		self.structure = ()

	def generer(self):
		with open(self.fichier, 'r') as fichier:
		 structure_niveau = []

		 for ligne in fichier:
			 ligne_niveau = []

			 for sprite in ligne:
			  if sprite != '\n':
			   ligne_niveau.append(sprite)

			 structure_niveau.append(ligne_niveau)
		self.structure = structure_niveau
            
	def afficher(self,fenetre):
		#C'est dans cette partie que j'ai mis du coup les images et le 'taille_sprite' et me retrouve sans mon erreur
		num_ligne = 0
		for ligne in self.structure:

			num_case = 0
			for sprite in ligne:

				x = num_case * taille_sprite
				y = num_ligne * taille_sprite
				if sprite == 'a':
					fenetre.blit(asteroid, (x,y))
				elif sprite == 'f':
					fenetre.blit(flag, (x,y))
				elif sprite == 'r':
					fenetre.blit(rambarde, (x,y))

				num_case += 1
			num_ligne +=1

"""
Jeu Agent69
"""
import pygame
from pygame.locals import *
from classes import *

pygame.init()

fenetre = pygame.display.set_mode((720,480))

fond = pygame.image.load('images/etoilen1.png').convert_alpha()

#Le taille_sprite qui n'est pas vu par la classe
taille_sprite = 16

icone = pygame.image.load('images/icone.png').convert()
pygame.display.set_caption('Agent 69')

continuer = True
accueil = pygame.image.load('images/accueil.jpg').convert()

#Les fameuses images que je mets ici mais ne sont pas vus par la classe
asteroid = pygame.image.load('images/asteroid.png').convert()
flag = pygame.image.load('images/flag.png').convert()
rambarde = pygame.image.load('images/rambarde.png').convert()

pygame.key.set_repeat(30,30)
fps = 60
control_fps = pygame.time.Clock()

perso = Perso(fenetre)

while continuer:
    fenetre.blit(accueil, (0,0))
    pygame.display.flip()
	
    continuer_jeu = True
    continuer_accueil = True
	
    while continuer_accueil:
        control_fps.tick(fps)
		
        for event in pygame.event.get():
            if event.type == QUIT or event.type == KEYDOWN and event.key == K_ESCAPE :
                continuer_accueil = False
                continuer_jeu = False
                continuer = False
                choix = False
				
            elif event.type == KEYDOWN:
                if event.key == K_RETURN:
                    continuer_accueil = False
                    choix = 'n1'
    
    if choix:
        
        niveau = Niveau('n1')
        niveau.generer()
        niveau.afficher(fenetre)
        
        while continuer_jeu:
            
            control_fps.tick(fps)
            events = pygame.event.get()
            
            for event in events:
                
                if event.type == QUIT:
                    continuer_jeu = False
                    continuer = False
                
                elif event.type == KEYDOWN:
                    if event.key == K_ESCAPE:
                        continuer_jeu = False

            fenetre.blit(fond, (0,0))
            perso.afficher(events)

            pygame.display.flip()

Et le niveau, on sait jamais, peut être que l'erreur vient aussi de ça !

r0r000000000000000r00000000
000000000000000000000000000
000000000000000000000000000
000000000000000000000000000
00000000000000000000000000f
rrrrrrrr0000a0000a0000a00rr

Pour les variables asteroid, taille sprite, flag et rambare c'est normal que ça marche tes variables ne viennent pas de la classe et en plus elle ne vienne pas du même fichier donc aucune chance qu'il les trouvent. Il faut que tu les mettent en attribut de la classe Niveau puisque ces éléments appartiennent au niveau

Bien le bonjour, alors, j'ai ENFIN un niveau qui apparaît ainsi que mon personnage, je suis désormais confronté à deux problèmes, le premier, mon personnage qui se situe en haut à gauche (j'ai bien essayé de le déplacer mais on en revient au même problème ->) mais qui ne se déplace pas lorsque j'appuie sur les touches, il reste statique avec simplement un changement d'animation (bizarre :/)

Mon autre et dernier problème va être d'instaurer une gravité, j'ai essayé d'instaurer une vitesse qui pousse constamment mon personnage vers le bas, donc s'il saute, il sera appuyé vers le bas, mais vu que mon perse reste fixe, je ne peux pas vérifier son fonctionnement, donc j'aimerais si possible une grande aide pour le problème de personnage, et quelques pistes de recherches pour la gestion de sauts et/ou gravité !

Merci à vous !!

-
Edité par THE RU[i]NNER 24 mars 2018 à 16:11:36

ligne 27 30 et 33:

self.rect.move(-self.speed,0)
# il faut ecrire:
# self.rect = self.rect.move(-self.speed,0)

-
Edité par Coliculus 25 mars 2018 à 21:12:58

Merci, effectivement, c'était cela !

Désormais, j'en suis à l'étape suivante qui me semble essentielle avant d'instaurer un petit peu de gravité ! Ce sont les rect, en effet, là dessus je n'y connais pas grand chose, je me documente du coup et entre autres, j'ai cru comprendre qu'il faut définir du coup dans la classe la partie 'rect' de notre personnage, soit j'ai mis :

self.rect = pygame.Rect(32,32,16,16)

Sauf que je ne sais pas trop comment mettre en 'rect' mes asteroids et autres, j'ai bien essayé de faire :

if sprite == 'a':
					fenetre.blit(asteroid, (x,y))
					self.rect = pygame.Rect(64,64,16,16)

Mais après diverses essais, je me retrouve encore bloqué ! Vu que tu m'as déjà énormément aidé, je ne veux pas t'embêter d'avantage avec mon absence de connaissances la dessus mais surtout de compréhension, (faut dire aussi que le python nous est un peu tombé sous le nez, on a commencé, j'ai du apprendre les classes, l'orienté objet et toutes ces choses dans le tas, même si c'est la manière la plus efficace d'apprendre, ca reste la plus difficile et nécessite régulièrement une aide extèrieure !!) donc j'aimerais quelques pistes la dessus sans trop trop avancer, c'est à dire un élément, que j'essaie à diverses échelles etc et en déduire de moi meme la réponse ! 

Merci encore et toujours !!

tu devrais faire comme je te l'ais conseillé au début, les astéroïdes devrait être une classe, un exemple:

class asteroid:
    def __init__(self,position):
        self.image = pygame.image.load("images/asteroid.png").convert_alpha()
        self.rect = self.image.get_rect()
        self.rect = pygame.Rect(self.rect).move_ip(position)

    def get_pos(self):
        return (self.rect[0],self.rect[1])

    def afficher(self,fenetre):
        fenetre.blit(self.image,self.get_pos())

-
Edité par Coliculus 26 mars 2018 à 22:55:52

D'accord, donc je me suis occupé de créer des classes, du coup en définissant à chaque fois les différentes choses mais je me retrouve tout de même avec une erreur, j'ai donc essayé d'ajouter dans Niveau, self.asteroid etc, que j'aurai la possibilité de n'essayer que demain !

Je suppose que vu que c'est désormais une classe, il faut l'instaurer dans le niveau, j'ai bien entendu retiré les asteroid = pygame.etc

Voici le nouveau code pour le plaisir des yeux

EDIT : Je suppose aussi que les [0] etc don matrices doivent etre modifiés par les 'a' non ? Je viens de m'en rendre compte, parce que la ils ne sont appliqués à rien par rapport au niveau...

Le message d'erreur est le suivant, ligne 93 de classes, argument 1 must be pygame.Surface, not type

"""
Jeu Agent69
"""
import pygame
from pygame.locals import *
from classes import *

pygame.init()

fenetre = pygame.display.set_mode((1080,720))

fond = pygame.image.load('images/etoilen1.jpg').convert_alpha()


icone = pygame.image.load('images/icone.png').convert()
pygame.display.set_caption('Agent 69')

continuer = True
accueil = pygame.image.load('images/accueil.jpg').convert()

asteroid = pygame.image.load('images/asteroid.png').convert_alpha()
flag = pygame.image.load('images/flag.png').convert_alpha()
rambarde = pygame.image.load('images/rambarde.png').convert_alpha()

pygame.key.set_repeat(10,10)
fps = 60
control_fps = pygame.time.Clock()

perso = Perso(fenetre)

while continuer:
    fenetre.blit(accueil, (0,0))
    pygame.display.flip()
	
    continuer_jeu = True
    continuer_accueil = True
	
    while continuer_accueil:
        control_fps.tick(fps)
		
        for event in pygame.event.get():
            if event.type == QUIT or event.type == KEYDOWN and event.key == K_ESCAPE :
                continuer_accueil = False
                continuer_jeu = False
                continuer = False
                choix = False
				
            elif event.type == KEYDOWN:
                if event.key == K_RETURN:
                    continuer_accueil = False
                    choix = 'n1'
    
    if choix:
        
        niveau = Niveau(choix)
        niveau.generer()
        niveau.afficher(fenetre)
        
        while continuer_jeu:
            
            control_fps.tick(fps)
            events = pygame.event.get()
            
            for event in events:
                
                if event.type == QUIT:
                    continuer_jeu = False
                    continuer = False
                
                elif event.type == KEYDOWN:
                    if event.key == K_ESCAPE:
                        continuer_jeu = False

            fenetre.blit(fond, (0,0))
            niveau.afficher(fenetre)
            perso.affichage(events)

            pygame.display.flip()

"""
Classes Agent 69
"""
import pygame
from pygame.locals import *


class asteroid:
	def __init__(self,position):
		self.image = pygame.image.load("images/asteroid.png").convert_alpha()
		self.rect = self.image.get_rect()
		self.rect = pygame.Rect(self.rect).move_ip(position)
		
	def get_pos(self):
		return (self.rect[0],self.rect[1])
	
	def afficher(self,fenetre):
		fenetre.blit(self.image,self.get_pos())

class platform:
	def __init__(self,position):
		self.image = pygame.image.load("images/platform.gif").convert_alpha()
		self.rect = self.image.get_rect()
		self.rect = pygame.Rect(self.rect).move_ip(position)
		
	def get_pos(self):
		return (self.rect[0],self.rect[1])
	
	def afficher(self,fenetre):
		fenetre.blit(self.image,self.get_pos())
		
class flag:
	def __init__(self,position):
		self.image = pygame.image.load("images/flag.png").convert_alpha()
		self.rect = self.image.get_rect()
		self.rect = pygame.Rect(self.rect).move_ip(position)
		
	def get_pos(self):
		return (self.rect[0],self.rect[1])
	
	def afficher(self,fenetre):
		fenetre.blit(self.image,self.get_pos())

class rambarde:
	def __init__(self,position):
		self.image = pygame.image.load("images/rambarde.png").convert_alpha()
		self.rect = self.image.get_rect()
		self.rect = pygame.Rect(self.rect).move_ip(position)
		
	def get_pos(self):
		return (self.rect[0],self.rect[1])
	
	def afficher(self,fenetre):
		fenetre.blit(self.image,self.get_pos())



class Niveau:
	def __init__(self, fichier):
		self.asteroid = asteroid
		self.rambarde = rambarde
		self.flag = flag
		self.platform = platform
		self.fichier = fichier
		self.structure = ()

	def generer(self):
		with open(self.fichier, 'r') as fichier:
		 structure_niveau = []

		 for ligne in fichier:
			 ligne_niveau = []

			 for sprite in ligne:
			  if sprite != '\n':
			   ligne_niveau.append(sprite)

			 structure_niveau.append(ligne_niveau)
		self.structure = structure_niveau
            
	def afficher(self,fenetre):
		taille_sprite = 64

		num_ligne = 0
		for ligne in self.structure:

			num_case = 0
			for sprite in ligne:

				x = num_case * taille_sprite
				y = num_ligne * taille_sprite
				if sprite == 'a':
					fenetre.blit(asteroid, (x,y))
				elif sprite == 'f':
					fenetre.blit(flag, (x,y))
				elif sprite == 'r':
					fenetre.blit(rambarde, (x,y))

				num_case += 1
			num_ligne +=1


class Perso:
	def __init__(self,fenetre):
		self.fenetre = fenetre
		self.static = pygame.image.load('images/test.png').convert_alpha()
		self.droite = pygame.image.load('images/droite.gif').convert_alpha()
		self.gauche = pygame.image.load('images/gauche.gif').convert_alpha()
		self.haut = pygame.image.load('images/haut.gif').convert_alpha()
		self.bas = pygame.image.load('images/test.png').convert_alpha()
		self.case_x = 0
		self.case_y = 0
		self.x = 0
		self.y = 0

		self.current = self.static

		self.rect = self.static.get_rect()
		self.speed = 5

	def get_pos(self):
		return [self.rect[0],self.rect[1]]

	def move(self,events):
		for event in events:
			if event.type == KEYDOWN:
				if event.key == K_LEFT:
					self.rect = self.rect.move(-self.speed,0)
					self.current = self.gauche
				elif event.key == K_RIGHT:
					self.rect = self.rect.move(self.speed,0)
					self.current = self.droite
				elif event.key == K_UP:
					self.rect = self.rect.move(0,-self.speed)
					self.current = self.haut
				elif event.key == K_DOWN:
					self.rect = self.rect.move(0,self.speed)
					self.current = self.bas
				elif event.key == K_UP and K_RIGHT:
					self.rect = self.rect.move(self.speed,-self.speed)
					self.current = self.haut
			elif event.type == KEYUP:
				self.current = self.static

	def affichage(self,events):
		self.move(events)
		self.fenetre.blit(self.current,self.get_pos())
  

-
Edité par THE RU[i]NNER 28 mars 2018 à 18:08:15