Bonjour,

je fais un jeu tron mais le problème est que l'image est décalée par rapport à la tête. Pouvez vous m'aider ?

programme principale: (peut être devriez vous regarder vers les lignes 40)

from pygame import *
from classes import*
from constantes import*
 
 
 

fenetre = display.set_mode((x * one, y * one))
 
# init des motos
moto_a = [(0, 0), (0, 1)]

tete_a = moto_a[-1]
 
moto_b = [(x - 1, y - 1), (x - 1, y - 2)]
tete_b = moto_b[-1]
 
# initialisation d'un tableau pour les collisions entre les deux motos
plateau = [[0 for i in range(x)] for j in range(y)]
plateau[0][0] = 1
plateau[0][1] = 1
 
plateau[9][9] = 1
plateau[9][8] = 1
 
# direction
direction_a = (0, 1)
direction_b = (0, -1)
 

le_joueur_a = joueurs(moto_a[-1])
le_joueur_b = joueurs(moto_b[-1])

 
continuer_jeu = 1
 
# Boucle du jeux
while continuer_jeu:
    fenetre.fill(BLACK)
    le_joueur_a.rect.center = (tete_a[0]*one,tete_a[1]*one)
    le_joueur_b.rect.center = (tete_b[0]*one,tete_b[1]*one)
    print(le_joueur_a.rect)  
    # tant que le tete ne depasse pas les bords et que la mot n'a qu'une tete (si 2 tetes alors "elle s'est mordu")
    if 0 <= tete_a[0] < x and 0 <= tete_a[1] < x and moto_a.count(tete_a) and 1:
        if 0 <= tete_b[0] < x and 0 <= tete_b[1] < x and moto_b.count(tete_b) and 1:
            # changement de direction en fonction des touches
            for ev in event.get(KEYDOWN):
 
                if ev.key == K_LEFT:
                    direction_a = (-1, 0)
                    directiona = 'gauche_a'
                    le_joueur_a.direction_a(directiona)

                elif ev.key == K_RIGHT:
                    direction_a = (1, 0)
                    directiona = 'droite_a'
                    le_joueur_a.direction_a(directiona)

                elif ev.key == K_UP:
                    direction_a = (0, -1)
                    directiona = 'haut_a'
                    le_joueur_a.direction_a(directiona)

                elif ev.key == K_DOWN:
                    direction_a = (0, 1)
                    directiona = 'bas_a'
                    le_joueur_a.direction_a(directiona)

                if ev.key == K_f:
                    direction_b = (-1, 0)
                    direction = 'gauche_b'
                    le_joueur_b.direction_a(direction)

                elif ev.key == K_h:
                    direction_b = (1, 0)
                    direction = 'droite_b'
                    le_joueur_b.direction_a(direction)

                elif ev.key == K_t:
                    direction_b = (0, -1)
                    direction = 'haut_b'
                    le_joueur_b.direction_a(direction)

                elif ev.key == K_g:
                    direction_b = (0, 1)
                    direction = 'bas_b'
                    le_joueur_b.direction_a(direction)

 
            # si la tete est différent de la fenetre,on ajoute une nouvelle tete, donc on ajoute toujours une case tant qu'elle est dans la fenetre
            moto_a = moto_a[0 if tete_a != fenetre else 1:] + [(tete_a[0] + direction_a[0], tete_a[1] + direction_a[1])]
            moto_b = moto_b[0 if tete_b != fenetre else 1:] + [(tete_b[0] + direction_b[0], tete_b[1] + direction_b[1])]

            # quand la moto passe sur une case, cette dermière prend la valeur 1, et si la moto passe par une case de valeur 1....collision
            try:
                if plateau[tete_a[0] + direction_a[0]][tete_a[1] + direction_a[1]] == 1:
 
                    continuer_jeu = 0
                elif plateau[tete_b[0] + direction_b[0]][tete_b[1] + direction_b[1]] == 1:
                    continuer_jeu = 0
            except:
                pass
 
 
 
 
            else:
                plateau[tete_a[0] + direction_a[0]][tete_a[1] + direction_a[1]] = 1
            plateau[tete_b[0] + direction_b[0]][tete_b[1] + direction_b[1]] = 1
 
            # *********************************************************************
            # ici la partie rendu
            # pour l'instant on dessine des carres pour verifier le fonctionnement
            for i in moto_a + []:
                fenetre.fill((228,43,61), (i[0] * one, i[1] * one, one, one))
            for z in moto_b + []:
                fenetre.fill((74,139,221), (z[0] * one, z[1] * one, one, one))
            fenetre.blit(le_joueur_a.image,le_joueur_a.rect)
            fenetre.blit(le_joueur_b.image,le_joueur_b.rect)
            display.flip()
 
            # *********************************************************************
            # on n'oublie pas d'aligner les variables
            tete_a = moto_a[-1]
            tete_b = moto_b[-1]
 
            # comme on filtre les events, par principe on clear la event queue
            event.clear()
 
            # tempo
            time.wait(100)
        else:
            continuer_jeu = 0 and print("collision moto b")
 
    else:
        continuer_jeu = 0 and print(" collision moto a")
 
print(continuer_jeu)

classes:

import pygame
from pygame.locals import*
from constantes import*
 
class joueurs:
    def __init__(self,position_départ):
 
        self.droite_a = pygame.image.load('motodroite_a.png').convert_alpha()
        self.gauche_a = pygame.image.load('motogauche_a.png').convert_alpha()
        self.haut_a = pygame.image.load('motohaut_a.png').convert_alpha()
        self.bas_a = pygame.image.load('motobas_a.png').convert_alpha()

        self.image = self.bas_a

        self.rect = self.image.get_rect()

        self.rect.topleft = position_départ

 
    def direction_a(self,direction):
 
        if direction == 'gauche_a':
            self.image=self.gauche_a
 
        if direction == 'droite_a':
            self.image=self.droite_a
 
        if direction == 'haut_a':
            self.image=self.haut_a
 
        if direction == 'bas_a':
            self.image=self.bas_a
 
    def direction_b(self,direction):
 
        if direction == 'gauche_b':
            self.image=self.gauche_b
 
        if direction == 'droite_b':
            self.image=self.droite_b
 
        if direction == 'haut_b':
            self.image=self.haut_b
 
        if direction == 'bas_b':
            self.image=self.bas_b

Pour l'instant j'ai fais que l'affichage de la tête a donc c'est normale si le système d'affichage pour tête b n'est pas complet...

constantes:

x, y = 60, 60
one = 10

BLACK = (0,0,0)
WHITE = (255,255,255)

Merci d'avance

-
Edité par OscarDurand 22 mai 2018 à 20:49:30