Comment faire sauter un cube dans pygame ?

Résolu
ZHN -  
 Jean -

Hello !

je suis en 1ere et spé NSI - on doit donc faire un jeu. J'utilise pygame (et pycharm) - je dois faire sauter mon cube, mais je n'y arrive pas. Une solution TwT ?

 
import pygame
import self as self
from pygame import *


# Taille de l'écran (provisoir)
LARGEUR_ECRAN = 1600
HAUTEUR_ECRAN = 850

# Classe définissant le personnage
#(pour l'instant il y a que son deplacement dans tt l'ecran il faut le resreindre et ajouter tt ses fonctions)


class Personnage (pygame.sprite.Sprite):

    # Iniialisation du perso
    def __init__(self):
        
         super(Personnage, self).__init__()
         
         #forme à remplacer par une image
         self.surf = pygame.Surface ((80, 80))
         self.surf.fill ((255, 255, 255))
         self.rect = self.surf.get_rect ()
         
         #coordonnées de base à modifier aussi
         self.rect.x= 200
         self.rect.y= 520

         self.saut_montee = 0
         self.saut_descente = 3
         self.nombre_de_saut = 0
         #self.resistance
         #self.gravity
         
         self.pointdevie=3


    def saut(self):
        sauter = True
        gravite = 1
        sauth = 1
        rapidite = sauth


    # Mise à jour quand le joueur appuie sur une touche pour le déplacer
    def update(self, pressed_keys):

        # Déplacement vers la gauche
        if pressed_keys[K_LEFT]:
            self.rect.move_ip(-5, 0)
        # Déplacement vers la droite
        if pressed_keys[K_RIGHT]:
            self.rect.move_ip(5, 0)

        if pressed_keys[K_UP]:
            saut=True

        if self.rect.left<0:
            self.rect.left=0
        if self.rect.right>LARGEUR_ECRAN:
            self.rect.right = LARGEUR_ECRAN

        if self.rect.y<0:
            self.rect.y=0
        if self.rect.y>520:
            self.rect.y=520



class Obstacle (pygame.sprite.Sprite):
   
    """
cette classe est vrm bancale mais elle s'affiche. le 
but c'est que l'obsatcle ce deplace vers la gauche continuellement 
jusqu'a la sortie de l'ecran
et à terme qu'il y ai plusieurs sous class d'obstacle avec des formes et 
des effets different (comme dans geometry dash) 
et que quand coordonnés obstacle=coordonnées personnage (colision) ça enleve un point
"""
   
    def __init__ (self):
        
         super (Obstacle, self).__init__()
         
         #forme à remplacer par une image
         self.surf = pygame.Surface ((60, 60))
         self.surf.fill ((255, 0, 55))
         self.rect = self.surf.get_rect ()


     
         self.rect.x = 1500
         self.rect.y= 520



# Réglage de l'horloge
clock = pygame.time.Clock()

# Groupe de Sprites
tous_sprites = pygame.sprite.Group()


# Création des éléments (c'est pour que les element des classes s'affichent)
player = Personnage()
obstacles=Obstacle()
tous_sprites.add(player)
tous_sprites.add(obstacles)

# Initialisation de la page
pygame.init()
pygame.display.set_caption("test jeu")
ecran = pygame.display.set_mode([LARGEUR_ECRAN, HAUTEUR_ECRAN])
#fond = pygame.image.load("images/background.png")

# Game loop (boucle continue qui met continuellement le jeu à jour)
continuer = True
while continuer:


    # fermer la fenetre
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            continuer = False



    # ecran noir (provisoir)
    #fd
    ecran.fill((120, 170, 255))

#sol
    pygame.draw.rect (ecran, (100, 200, 80), (0, 600, 1600, 350))

    #touches
    touche_appuyee = pygame.key.get_pressed()
    player.update(touche_appuyee)

    # Recopie des objets sur la surface ecran
    for mon_sprite in tous_sprites:
        ecran.blit(mon_sprite.surf, mon_sprite.rect)
        
    

    # On passe notre surface pour l'afficher
    pygame.display.flip()

    # Indique à Pygame de ne pas faire plus de 50 fois par seconde la gameloop pour ralentir le déplacement
    clock.tick(100)
pygame.quit()

Merci. :)
Windows / Chrome 109.0.0.0

A voir également:

9 réponses

Réponse 1 / 9
Diablo76 Messages postés 269 Statut Membre 86
 

Salut,

Il est vrai que si tu débutes, se lancer dans la programmation orientée objet risque fort de te démotiver :( , mais si tu fais une recherche sur le net, tu devrais trouver des exemples qui sont plus à ta portée comme celui-ci :

import pygame
pygame.init()

win = pygame.display.set_mode((500,500))
pygame.display.set_caption("First Game")

x = 100
y = 400
width = 40
height = 60
vel = 10

isJump = False
jumpCount = 10

run = True

while run:
    pygame.time.delay(30)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            run = False

    keys = pygame.key.get_pressed()
    
    if keys[pygame.K_LEFT] and x > vel: 
        x -= vel

    if keys[pygame.K_RIGHT] and x < 500 - vel - width:  
        x += vel
        
    if not(isJump): 
        if keys[pygame.K_UP] and y > vel:
            y -= vel

        if keys[pygame.K_DOWN] and y < 500 - height - vel:
            y += vel

        if keys[pygame.K_SPACE]:
            isJump = True
    else:
        if jumpCount >= -10:
            y -= (jumpCount * abs(jumpCount)) * 0.5
            jumpCount -= 1
        else: 
            jumpCount = 10
            isJump = False
    
    win.fill((0,0,0))
    pygame.draw.rect(win, (255,0,0), (x, y, width, height))   
    pygame.display.update() 
    
pygame.quit()

A toi de le comprendre et de le modifier pour ton exo.
3
ZHN
 

Yess ! Merci ! J'ai réussi à l'adapter à mon code & j'ai compris ttes les lignes !!

Merci beaucoup :D

0
Jean
 

euh bonjour :)))

j'ai une question similaire à celle de ZHN donc j'écris ici pour eviter d'ouvrir un doublon
Je compte aussi prendre la spé NSI et donc j'ai commencé à apprendre quelques trucs. Par contre, dans mon code, je ne comprends pas comment est ce que je pourrais faire pour faire sauter le joueur même quand ile st dans les airs (comme dans flappy bird xd)

import pygame
import random

# Initialisation de Pygame
pygame.init()

# Définition des dimensions de la fenêtre de jeu
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600

# Couleurs
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
COLLO = (98, 119, 29)
BROWN = (153, 76, 0)
COLOR = (100, 100, 99)

# Créationde la fenêtre de jeu
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))


# Classe pour la création des ennemis
class Enemy(pygame.sprite.Sprite):
    def __init__(self, obstacles):
        super().__init__()
        self.image = pygame.Surface((50, 50))
        self.image.fill(BLACK)
        self.rect = self.image.get_rect()
        self.rect.x = SCREEN_WIDTH
        self.rect.y = random.randint(0, SCREEN_HEIGHT - 100)
        while self.rect.bottom > SCREEN_HEIGHT - 50:
            self.rect.y = random.randint(0, SCREEN_HEIGHT - 100)
        self.speed = 3
        self.obstacles = obstacles

    def update(self):
        self.rect.x -= self.speed

        # Vérifie s'il y a une collision avec un obstacle
        for obstacle in self.obstacles:
            if self.rect.colliderect(obstacle.rect):
                self.rect.right = obstacle.rect.left

class Obstacle(pygame.sprite.Sprite):
    def __init__(self):
        super().__init__()
        self.image = pygame.Surface((50, 50))
        self.image.fill(COLOR)
        self.rect = self.image.get_rect()
        self.rect.x = SCREEN_WIDTH
        self.rect.y = random.randint(0, SCREEN_HEIGHT - 100)
        while self.rect.bottom > SCREEN_HEIGHT - 50:
            self.rect.y = random.randint(0, SCREEN_HEIGHT - 100)
        self.speed = random.randint(1, 3)

    def update(self):
        self.rect.x -= self.speed

class Ground(pygame.sprite.Sprite):
    def __init__(self):
        super().__init__()
        self.image = pygame.Surface((SCREEN_WIDTH, 50))
        self.image.fill(BROWN)
        self.rect = self.image.get_rect()
        self.rect.x = 0
        self.rect.y = SCREEN_HEIGHT - 50


# Classe pour la création du joueur
class Player(pygame.sprite.Sprite):
    def __init__(self):
        super().__init__()
        self.image = pygame.Surface((50, 50))
        self.image.fill(COLLO)
        self.rect = self.image.get_rect()
        self.speed = 10
        self.jump_speed = 20
        self.is_jumping = False
        self.speed_y = 0


    def update(self, keys):
        if keys[pygame.K_UP] and not self.is_jumping:
            self.is_jumping = True
            self.speed_y = -self.jump_speed

        if self.is_jumping or self.rect.bottom < SCREEN_HEIGHT - 50:
            self.speed_y += 1
            self.rect.y += self.speed_y

            if self.rect.bottom >= SCREEN_HEIGHT - 50:
                self.rect.bottom = SCREEN_HEIGHT - 50
                self.is_jumping = False
                self.speed_y = 0


# Création des sprites pour les ennemis et le joueur
all_sprites = pygame.sprite.Group()
enemies = pygame.sprite.Group()
obstacles = pygame.sprite.Group()
player = Player()
all_sprites.add(player)
ground = Ground()
all_sprites.add(ground)

# Place the player on the ground
player.rect.y = SCREEN_HEIGHT - 100

# Boucle principale du jeu
running = True
clock = pygame.time.Clock()
score = 0
enemy_timer = 0
enemy_spawn_rate = 800
obstacle_timer = 0
obstacle_spawn_rate = 1600

while running:
    # Gestion des événements
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False


    enemy_timer += clock.get_time()
    if enemy_timer >= enemy_spawn_rate:
        enemy = Enemy(obstacles)
        all_sprites.add(enemy)
        enemies.add(enemy)
        enemy_timer = 0

    obstacle_timer += clock.get_time()
    if obstacle_timer >= obstacle_spawn_rate:
        obstacle = Obstacle()
        all_sprites.add(obstacle)
        obstacles.add(obstacle)
        obstacle_timer = 0

    # Déplacement des ennemis et collision avec le joueur
    for enemy in enemies:
        enemy.update()
        if enemy.rect.right < 0:
            enemies.remove(enemy)
            all_sprites.remove(enemy)
        if enemy.rect.colliderect(player.rect):
            running = False

    for obstacle in obstacles:
        obstacle.update()
        if obstacle.rect.right < 0:
            obstacles.remove(obstacle)
            all_sprites.remove(obstacle)
        if obstacle.rect.colliderect(player.rect):
            running = False


    keys = pygame.key.get_pressed()
    player.update(keys)

    # Affichage des ennemis et du joueur
    screen.fill(WHITE)
    all_sprites.draw(screen)
    pygame.display.flip()

    # Limite de 60 images par seconde
    clock.tick(80)

# Fermeture de Pygame
pygame.quit()
0
yg_be Messages postés 24281 Statut Contributeur 1 584 > Jean
 

SI tu ne trouves pas la réponse ici, il est préférable de créer une nouvelle discussion.

1
Jean > yg_be Messages postés 24281 Statut Contributeur
 

ok :) merci

0
Réponse 2 / 9
yg_be Messages postés 24281 Statut Contributeur Ambassadeur 1 584
 

bonjour, tu ne peux déplacer ton cube vers le haut?  qu'as-tu essayé?
0
Réponse 3 / 9
ZHN
 

Salut merci de me répondre :)

Bah j'ai d'abord essayer de

- de pouvoir déplacer le cube avec les fleches de haut en bas dans toute la surface - ca ca a marché

- ensuite j'ai voulu le faire sauter quand on touche a espace ou a la fleche du haut mais ca ca marche pas trop (pas du tout xd) j'ai fait une fonction sauter 

def sauter(self):
       if self.a_sauter:
           if self.saut_montee>=10:
               self.saut_descente-=1
               self.saut=self.saut_descente
            
           else:
                self.saut_montee+=1
                self.saut=self.saut_montee
            
           if self.saut_descente<0:
               self.saut_montee=0
               self.saut_descente=5
               self.saut.a_sauter = False
                
       self.rect.y=self.rect.y - (10*(self.saut/2))

j'ai mis ca dans la classe Perso, j'ai érit ca dans la boucle de base du jeu 

if event.key == pygame.K_UP:
                    self.perso.a_sauter = True

                   self.perso.nombre_de_saut+=1

Et puis à la fin j'ai appelé la fonction sauter, mais pareil ca marche pas non plus

Ensuite j'ai suivi un autre tuto mais le jeu ne s'ouvre pas alors qu'il n'y a aucune erreur dans le code :(((

La mon but c'est juste de faire sauter le cube avec space ou la fleche du haut
0
yg_be Messages postés 24281 Statut Contributeur 1 584
 

Pourquoi n'as-tu pas ajouté le code pour sauter à la ligne 58, plutôt que dans la boucle "de base"?

0
Réponse 4 / 9
ZHN
 

le code avec la fonction def sauter(self): ?

import pygame
import self as self
from pygame import *


# Taille de l'écran (provisoir)
LARGEUR_ECRAN = 1600
HAUTEUR_ECRAN = 850

# Classe définissant le personnage
#(pour l'instant il y a que son deplacement dans tt l'ecran il faut le resreindre et ajouter tt ses fonctions)


class Personnage (pygame.sprite.Sprite):

    # Iniialisation du perso
    def __init__(self):
        
         super(Personnage, self).__init__()
         
         #forme à remplacer par une image
         self.surf = pygame.Surface ((80, 80))
         self.surf.fill ((255, 255, 255))
         self.rect = self.surf.get_rect ()
         
         #coordonnées de base à modifier aussi
         self.rect.x= 200
         self.rect.y= 520

         self.saut_montee = 0
         self.saut_descente = 3
         self.nombre_de_saut = 0
         #self.resistance
         #self.gravity
         
         self.pointdevie=3

    def sauter(self):
        if self.a_sauter:
            if self.saut_montee >= 10:
                self.saut_descente -= 1
                self.saut = self.saut_descente

            else:
                self.saut_montee += 1
                self.saut = self.saut_montee

            if self.saut_descente < 0:
                self.saut_montee = 0
                self.saut_descente = 5
                self.saut.a_sauter = False

        self.rect.y = self.rect.y - (10 * (self.saut / 2))

    # Mise à jour quand le joueur appuie sur une touche pour le déplacer
    def update(self, pressed_keys):

        # Déplacement vers la gauche
        if pressed_keys[K_LEFT]:
            self.rect.move_ip(-5, 0)
        # Déplacement vers la droite
        if pressed_keys[K_RIGHT]:
            self.rect.move_ip(5, 0)

        if pressed_keys[K_UP]:
            self.a_sauter = True

        self.nombre_de_saut += 1

        if self.rect.left<0:
            self.rect.left=0
        if self.rect.right>LARGEUR_ECRAN:
            self.rect.right = LARGEUR_ECRAN

        if self.rect.y<0:
            self.rect.y=0
        if self.rect.y>520:
            self.rect.y=520



class Obstacle (pygame.sprite.Sprite):
   
    """
cette classe est vrm bancale mais elle s'affiche. le 
but c'est que l'obsatcle ce deplace vers la gauche continuellement 
jusqu'a la sortie de l'ecran
et à terme qu'il y ai plusieurs sous class d'obstacle avec des formes et 
des effets different (comme dans geometry dash) 
et que quand coordonnés obstacle=coordonnées personnage (colision) ça enleve un point
"""
   
    def __init__ (self):
        
         super (Obstacle, self).__init__()
         
         #forme à remplacer par une image
         self.surf = pygame.Surface ((60, 60))
         self.surf.fill ((255, 0, 55))
         self.rect = self.surf.get_rect ()


     
         self.rect.x = 1500
         self.rect.y= 520



# Réglage de l'horloge
clock = pygame.time.Clock()

# Groupe de Sprites
tous_sprites = pygame.sprite.Group()


# Création des éléments (c'est pour que les element des classes s'affichent)
player = Personnage()
obstacles=Obstacle()
tous_sprites.add(player)
tous_sprites.add(obstacles)

# Initialisation de la page
pygame.init()
pygame.display.set_caption("test jeu")
ecran = pygame.display.set_mode([LARGEUR_ECRAN, HAUTEUR_ECRAN])
#fond = pygame.image.load("images/background.png")

# Game loop (boucle continue qui met continuellement le jeu à jour)
continuer = True
while continuer:


    # fermer la fenetre
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            continuer = False



    # ecran noir (provisoir)
    #fd
    ecran.fill((120, 170, 255))

#sol
    pygame.draw.rect (ecran, (100, 200, 80), (0, 600, 1600, 350))

    #touches
    touche_appuyee = pygame.key.get_pressed()
    player.update(touche_appuyee)

    # Recopie des objets sur la surface ecran
    for mon_sprite in tous_sprites:
        ecran.blit(mon_sprite.surf, mon_sprite.rect)
        
    

    # On passe notre surface pour l'afficher
    pygame.display.flip()

    # Indique à Pygame de ne pas faire plus de 50 fois par seconde la gameloop pour ralentir le déplacement
    clock.tick(100)
pygame.quit()

?
0
yg_be Messages postés 24281 Statut Contributeur 1 584
 

choisis "python" quand tu partages du code python: https://codes-sources.commentcamarche.net/faq/11288-poster-un-extrait-de-code

1
yg_be Messages postés 24281 Statut Contributeur 1 584
 

Où appelles-tu sauter()?

0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Réponse 5 / 9
ZHN
  
import pygame
import self as self
from pygame import *


# Taille de l'écran (provisoir)
LARGEUR_ECRAN = 1600
HAUTEUR_ECRAN = 850

# Classe définissant le personnage
#(pour l'instant il y a que son deplacement dans tt l'ecran il faut le resreindre et ajouter tt ses fonctions)


class Personnage (pygame.sprite.Sprite):

    # Iniialisation du perso
    def __init__(self):
        
         super(Personnage, self).__init__()
         
         #forme à remplacer par une image
         self.surf = pygame.Surface ((80, 80))
         self.surf.fill ((255, 255, 255))
         self.rect = self.surf.get_rect ()
         
         #coordonnées de base à modifier aussi
         self.rect.x= 200
         self.rect.y= 520

         self.saut_montee = 0
         self.saut_descente = 3
         self.nombre_de_saut = 0
         #self.resistance
         #self.gravity
         
         self.pointdevie=3

    def sauter(self):
        if self.a_sauter:
            if self.saut_montee >= 10:
                self.saut_descente -= 1
                self.saut = self.saut_descente

            else:
                self.saut_montee += 1
                self.saut = self.saut_montee

            if self.saut_descente < 0:
                self.saut_montee = 0
                self.saut_descente = 5
                self.saut.a_sauter = False

        self.rect.y = self.rect.y - (10 * (self.saut / 2))

    # Mise à jour quand le joueur appuie sur une touche pour le déplacer
    def update(self, pressed_keys):

        # Déplacement vers la gauche
        if pressed_keys[K_LEFT]:
            self.rect.move_ip(-5, 0)
        # Déplacement vers la droite
        if pressed_keys[K_RIGHT]:
            self.rect.move_ip(5, 0)

        if pressed_keys[K_UP]:
            self.a_sauter = True

        self.nombre_de_saut += 1

        if self.rect.left<0:
            self.rect.left=0
        if self.rect.right>LARGEUR_ECRAN:
            self.rect.right = LARGEUR_ECRAN

        if self.rect.y<0:
            self.rect.y=0
        if self.rect.y>520:
            self.rect.y=520



class Obstacle (pygame.sprite.Sprite):
   
    """
cette classe est vrm bancale mais elle s'affiche. le 
but c'est que l'obsatcle ce deplace vers la gauche continuellement 
jusqu'a la sortie de l'ecran
et à terme qu'il y ai plusieurs sous class d'obstacle avec des formes et 
des effets different (comme dans geometry dash) 
et que quand coordonnés obstacle=coordonnées personnage (colision) ça enleve un point
"""
   
    def __init__ (self):
        
         super (Obstacle, self).__init__()
         
         #forme à remplacer par une image
         self.surf = pygame.Surface ((60, 60))
         self.surf.fill ((255, 0, 55))
         self.rect = self.surf.get_rect ()


     
         self.rect.x = 1500
         self.rect.y= 520



# Réglage de l'horloge
clock = pygame.time.Clock()

# Groupe de Sprites
tous_sprites = pygame.sprite.Group()


# Création des éléments (c'est pour que les element des classes s'affichent)
player = Personnage()
obstacles=Obstacle()
tous_sprites.add(player)
tous_sprites.add(obstacles)

# Initialisation de la page
pygame.init()
pygame.display.set_caption("test jeu")
ecran = pygame.display.set_mode([LARGEUR_ECRAN, HAUTEUR_ECRAN])
#fond = pygame.image.load("images/background.png")

# Game loop (boucle continue qui met continuellement le jeu à jour)
continuer = True
while continuer:


    # fermer la fenetre
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            continuer = False



    # ecran noir (provisoir)
    #fd
    ecran.fill((120, 170, 255))

#sol
    pygame.draw.rect (ecran, (100, 200, 80), (0, 600, 1600, 350))

    #touches
    touche_appuyee = pygame.key.get_pressed()
    player.update(touche_appuyee)

    # Recopie des objets sur la surface ecran
    for mon_sprite in tous_sprites:
        ecran.blit(mon_sprite.surf, mon_sprite.rect)
        
    

    # On passe notre surface pour l'afficher
    pygame.display.flip()

    # Indique à Pygame de ne pas faire plus de 50 fois par seconde la gameloop pour ralentir le déplacement
    clock.tick(100)
pygame.quit()

il est dans la classe personnage et j'appelle la classe en bas 

jpeux l'appeler saut=sauter() ??
0
yg_be Messages postés 24281 Statut Contributeur 1 584
 

c'est ton premier exercice en python?

0
Réponse 6 / 9
ZHN
 

Oui :/
0
yg_be Messages postés 24281 Statut Contributeur 1 584
 

Je ne pense pas que tu vas progresser en essayant de modifier un programme que tu ne comprends pas.

Commence par un programme plus simple que tu fais toi-même.

0
Réponse 7 / 9
ZHN
 

Ok :( merci
0
Réponse 8 / 9
hudada
 

Salut.

Faire sauter un personnage ou un objet, c'est simuler la gravité, donc faire une décélération au fil de la montée, et inversement une accélération lors de la descente, l'un étant l'inverse de l'autre, autant se servir des valeurs de l'ascension pour la chute.

Un exemple evec quelques commentaires.

import pygame as pg

FPS = 60

SCREEN_WIDTH = 500
SCREEN_HEIGHT = 400
SCREEN_COLOR = (0, 0, 0)

PLAYER_COLOR = (255, 255, 0)
PLAYER_SPEED = 8

GRAVITY = 0.18


class Player(pg.sprite.Sprite):
    def __init__(self):
        super().__init__()
        # Un simple surface remplie d'une couleur
        self.image = pg.Surface((50, 50))
        self.image.fill(PLAYER_COLOR)
        self.rect = self.image.get_rect()
        self.jumping = False
        self.jumping_list = []

    def jump(self, height):
        if self.jumping:
            # Il y a un saut en cours
            # On ne va pas plus loin
            return
        self.jumping_height = height
        self.jumping_goal = self.rect.y - height
        self.jumping_list.append(self.rect.y)
        self.jumping = -1

    def left(self):
        self.rect.x -= PLAYER_SPEED

    def right(self):
        self.rect.x += PLAYER_SPEED

    def update(self):
        # Phase d'ascension
        if self.jumping == -1:
            dy = self.jumping_height * GRAVITY
            self.jumping_height -= dy
            self.rect.y -= dy
            # On ajoute le y à la liste afin de s'en servir lorsque
            # viendra la chute
            self.jumping_list.append(self.rect.y)
            if self.rect.y <= self.jumping_goal:
                # Ajout de 5 fois la valeur de la hauteur à atteindre
                # afin d'avoir un effet de "lourdeur" dans la chute
                self.jumping_list.extend([self.jumping_goal] * 5)
                # Indique d'on passe à la chute
                self.jumping = 1
        # Phase de descente
        elif self.jumping == 1:
            try:
                # On extrait la dernière valeur de la liste
                # que l'on affecte à la valeur y du joueur
                self.rect.y = self.jumping_list.pop()
            except IndexError:
                # La liste est vide, et donc on est revenu sur le sol
                # On cesse la phase de saut et on indique que le joueur peut à
                # nouveau sauter
                self.jumping = 0


screen = pg.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
screen_rect = screen.get_rect()

player = Player()
# On place le player en bas de l'écran et à 30 px du bord gauche
player.rect.bottomleft = 30, SCREEN_HEIGHT

# On crée un groupe de sprites puis on ajoute notre joueur à ce groupe.
draw_group = pg.sprite.Group()
draw_group.add(player)


clock = pg.time.Clock()
running = True

while running:
    for evt in pg.event.get():
        if evt.type == pg.QUIT:
            running = False

    pressed_keys = pg.key.get_pressed()
    if pressed_keys[pg.K_LEFT]:
        player.left()
    elif pressed_keys[pg.K_RIGHT]:
        player.right()
    if pressed_keys[pg.K_UP]:
        player.jump(100)
    # Permet que le joueur ne sorte pas des limites de l'écran
    player.rect.clamp_ip(screen_rect)

    screen.fill(SCREEN_COLOR)
    # Mise à jour du groupe, donc de tous les sprites du groupe
    draw_group.update()
    # Puis dessin des sprites
    draw_group.draw(screen)
    pg.display.update()
    clock.tick(FPS)

pg.quit()

Ajoute des print dans la méthode update du joueur pour bien comprendre si tu as un peu de mal à savoir ce que valent les variables et attributs.
0
Réponse 9 / 9
ZHN
 

j'en prends note !

Merci :)))
0

Discussions similaires

pygame sur pycharm
Clement_V -
mamiemando -

1 réponse
Google - J'ai de la chance
baissaoui -
baissaoui -

0 réponse
Coder le jeu Geometry dash en python
Utilisateur anonyme -
Utilisateur anonyme -

11 réponses
j'ai de la chance
albensam -
albensam -

3 réponses
Probleme j'ai de la chance
Jujoutch -
a ne marche pas mdr -

8 réponses