Ouais je sais que mon code est pas optimisé du tout mais c'est la première fois que j'utilisais le module draw.

La vitesse de la balle est fonction de la base de temps et non de la distance.

Ok mais pour augmenter la vitesse de la balle en plein milieu d'une partie devoir augmenter le nombre de cycle de calcul c'est pas un peu moyen comme solution ?

La balle a sa propre base de temps comme l'affichage. 

Ou bien tu peux faire varier la distance de déplacement en pixels en restant inférieur à la largeur de la raquette; même que tu peux utiliser des valeurs non entières,  genre 1,5 pixel.

J'ai essayé d'aplliquer la solution que tu avais proposée avec des valeurs décimales, mais du coup le collision avec les raquettes ne fonctionne plus donc retour au point de départ.

EDIT : le sujet n'est plus en résolu car je n'ai pas réussi à appliquer la solution d'Olygrim qui utilise les set

-
Edité par sofaman 27 août 2014 à 1:16:39

voici le code d'une balle rebondissante avec 2 méthodes de temporisation:

1- la balle se base sur le temps écoulé entre 2 appels à la méthode update(), celà implique que la boucle principale soit plus rapide que la balle.

2- l'affichage compte les cycles du mainloop pour se déclancher.

from pygame import *

fenetre      = display.set_mode((600,600))
fenetre_rect = fenetre.get_rect()

class Balle(object):
    
    rect     = Rect(0,0,5,5)
    centre_x = 400
    centre_y = 400
    rect.center = centre_x, centre_y
    
    vx = 1.17 # modifie vitesse et trajectoire horizontale
    vy = 1.63 # modifie vitesse et trajectoire verticale
    
    ck   = time.Clock()
    laps = 10 # modifie la vitesse en fonction du temps
    t    = 0
    
    @staticmethod
    def update():
        Balle.t += Balle.ck.tick()
        if Balle.t >= Balle.laps: # la balle bouge toutes les laps ms
            if not fenetre_rect.left < Balle.rect.left or Balle.rect.right > fenetre_rect.right:
                Balle.vx = -Balle.vx
            if not fenetre_rect.top < Balle.rect.top or Balle.rect.bottom > fenetre_rect.bottom:
                Balle.vy = -Balle.vy
            Balle.centre_x += Balle.vx
            Balle.centre_y += Balle.vy
            Balle.rect.centerx = int(Balle.centre_x)
            Balle.rect.centery = int(Balle.centre_y)
            Balle.t = 0

main_ck = time.Clock()
cycleps = 200 # frequence general du code
display_timebase = 40. # frequence de rafraichissement de l'affichage
display_t        = 0

while True:
    Balle.update()
    display_t += 1
    if display_t >= cycleps/display_timebase: # l'ecran est rafraichi toutes les 5 ms(200/40) soit 20 fps
        fenetre.fill(0)
        fenetre.fill(-1,Balle.rect)
        display.flip()
    main_ck.tick(cycleps)
    

vx et vy donnent un déplacement inférieur à 2 pixels.

On peut se retrouver avec un bug dû aux arrondis mais facilement gérable.

-
Edité par josmiley 27 août 2014 à 10:41:36

Ouais même si ta solution est vraiment bien, ça risque d'alourdir mon code alors que le problème d'une simple condition qui ne fonctionne pas correctement.

ça risque d'alourdir mon code

Bof, pas tellement, ça va déjà le rendre fonctionnel et au passage tu auras appris que nombre de frame par seconde et fréquence de traitement doivent la plupart du temps être décorrélées. Tout à tout à gagner, rien à y perdre.

Pour pseudo-régler ton problème de condition, la seule solution serait de détecter la collision à un nombre de pixel près égale à la vitesse de ta balle. M'enfin, faire une détection de collision à 6 pixels près, c'est sale.

-
Edité par Anonyme 27 août 2014 à 11:58:22

Ok ... c'est toi qui vois. 

Suffit de tester le dépassement de la raquette et ramener la balle sur le même axe que la raquette avant de tester la collision. 

Bon d'accord je vais essayer de le mettre en place mais j'ai une question à quoi sert @staticmethode ?

Argl...

Maintenant que je te donne la méthode du dépassement tu changes d'avis ...

Ouais je sais je suis chiant